WORST_CASE(?,O(n^2)) * Step 1: DependencyPairs WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: #abs(#0()) -> #0() #abs(#neg(x)) -> #pos(x) #abs(#pos(x)) -> #pos(x) #abs(#s(x)) -> #pos(#s(x)) #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0 ,#neg/1,#pos/1,#s/1,#true/0,dd/2,nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs,#cklt,#compare,#less,insert,insert#1,insert#2 ,insertD,insertD#1,insertD#2,insertionsort,insertionsort#1,insertionsortD ,insertionsortD#1} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: DependencyPairs {dpKind_ = DT} + Details: We add the following dependency tuples: Strict DPs #abs#(#0()) -> c_1() #abs#(#neg(x)) -> c_2() #abs#(#pos(x)) -> c_3() #abs#(#s(x)) -> c_4() #cklt#(#EQ()) -> c_5() #cklt#(#GT()) -> c_6() #cklt#(#LT()) -> c_7() #compare#(#0(),#0()) -> c_8() #compare#(#0(),#neg(y)) -> c_9() #compare#(#0(),#pos(y)) -> c_10() #compare#(#0(),#s(y)) -> c_11() #compare#(#neg(x),#0()) -> c_12() #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#neg(x),#pos(y)) -> c_14() #compare#(#pos(x),#0()) -> c_15() #compare#(#pos(x),#neg(y)) -> c_16() #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#0()) -> c_18() #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#1#(nil(),x) -> c_23() insert#2#(#false(),x,y,ys) -> c_24() insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#1#(nil(),x) -> c_28() insertD#2#(#false(),x,y,ys) -> c_29() insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsort#1#(nil()) -> c_33() insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) insertionsortD#1#(nil()) -> c_36() Weak DPs and mark the set of starting terms. * Step 2: UsableRules WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #abs#(#0()) -> c_1() #abs#(#neg(x)) -> c_2() #abs#(#pos(x)) -> c_3() #abs#(#s(x)) -> c_4() #cklt#(#EQ()) -> c_5() #cklt#(#GT()) -> c_6() #cklt#(#LT()) -> c_7() #compare#(#0(),#0()) -> c_8() #compare#(#0(),#neg(y)) -> c_9() #compare#(#0(),#pos(y)) -> c_10() #compare#(#0(),#s(y)) -> c_11() #compare#(#neg(x),#0()) -> c_12() #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#neg(x),#pos(y)) -> c_14() #compare#(#pos(x),#0()) -> c_15() #compare#(#pos(x),#neg(y)) -> c_16() #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#0()) -> c_18() #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#1#(nil(),x) -> c_23() insert#2#(#false(),x,y,ys) -> c_24() insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#1#(nil(),x) -> c_28() insertD#2#(#false(),x,y,ys) -> c_29() insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsort#1#(nil()) -> c_33() insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) insertionsortD#1#(nil()) -> c_36() - Weak TRS: #abs(#0()) -> #0() #abs(#neg(x)) -> #pos(x) #abs(#pos(x)) -> #pos(x) #abs(#s(x)) -> #pos(#s(x)) #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/2,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: UsableRules + Details: We replace rewrite rules by usable rules: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() #abs#(#0()) -> c_1() #abs#(#neg(x)) -> c_2() #abs#(#pos(x)) -> c_3() #abs#(#s(x)) -> c_4() #cklt#(#EQ()) -> c_5() #cklt#(#GT()) -> c_6() #cklt#(#LT()) -> c_7() #compare#(#0(),#0()) -> c_8() #compare#(#0(),#neg(y)) -> c_9() #compare#(#0(),#pos(y)) -> c_10() #compare#(#0(),#s(y)) -> c_11() #compare#(#neg(x),#0()) -> c_12() #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#neg(x),#pos(y)) -> c_14() #compare#(#pos(x),#0()) -> c_15() #compare#(#pos(x),#neg(y)) -> c_16() #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#0()) -> c_18() #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#1#(nil(),x) -> c_23() insert#2#(#false(),x,y,ys) -> c_24() insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#1#(nil(),x) -> c_28() insertD#2#(#false(),x,y,ys) -> c_29() insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsort#1#(nil()) -> c_33() insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) insertionsortD#1#(nil()) -> c_36() * Step 3: PredecessorEstimation WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #abs#(#0()) -> c_1() #abs#(#neg(x)) -> c_2() #abs#(#pos(x)) -> c_3() #abs#(#s(x)) -> c_4() #cklt#(#EQ()) -> c_5() #cklt#(#GT()) -> c_6() #cklt#(#LT()) -> c_7() #compare#(#0(),#0()) -> c_8() #compare#(#0(),#neg(y)) -> c_9() #compare#(#0(),#pos(y)) -> c_10() #compare#(#0(),#s(y)) -> c_11() #compare#(#neg(x),#0()) -> c_12() #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#neg(x),#pos(y)) -> c_14() #compare#(#pos(x),#0()) -> c_15() #compare#(#pos(x),#neg(y)) -> c_16() #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#0()) -> c_18() #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#1#(nil(),x) -> c_23() insert#2#(#false(),x,y,ys) -> c_24() insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#1#(nil(),x) -> c_28() insertD#2#(#false(),x,y,ys) -> c_29() insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsort#1#(nil()) -> c_33() insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) insertionsortD#1#(nil()) -> c_36() - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/2,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,18,23,24,28,29,33,36} by application of Pre({1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,18,23,24,28,29,33,36}) = {13,17,19,20,21,22,26,27,31,34}. Here rules are labelled as follows: 1: #abs#(#0()) -> c_1() 2: #abs#(#neg(x)) -> c_2() 3: #abs#(#pos(x)) -> c_3() 4: #abs#(#s(x)) -> c_4() 5: #cklt#(#EQ()) -> c_5() 6: #cklt#(#GT()) -> c_6() 7: #cklt#(#LT()) -> c_7() 8: #compare#(#0(),#0()) -> c_8() 9: #compare#(#0(),#neg(y)) -> c_9() 10: #compare#(#0(),#pos(y)) -> c_10() 11: #compare#(#0(),#s(y)) -> c_11() 12: #compare#(#neg(x),#0()) -> c_12() 13: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) 14: #compare#(#neg(x),#pos(y)) -> c_14() 15: #compare#(#pos(x),#0()) -> c_15() 16: #compare#(#pos(x),#neg(y)) -> c_16() 17: #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) 18: #compare#(#s(x),#0()) -> c_18() 19: #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) 20: #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) 21: insert#(x,l) -> c_21(insert#1#(l,x)) 22: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) 23: insert#1#(nil(),x) -> c_23() 24: insert#2#(#false(),x,y,ys) -> c_24() 25: insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) 26: insertD#(x,l) -> c_26(insertD#1#(l,x)) 27: insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) 28: insertD#1#(nil(),x) -> c_28() 29: insertD#2#(#false(),x,y,ys) -> c_29() 30: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) 31: insertionsort#(l) -> c_31(insertionsort#1#(l)) 32: insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) 33: insertionsort#1#(nil()) -> c_33() 34: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 35: insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) 36: insertionsortD#1#(nil()) -> c_36() * Step 4: RemoveWeakSuffixes WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak DPs: #abs#(#0()) -> c_1() #abs#(#neg(x)) -> c_2() #abs#(#pos(x)) -> c_3() #abs#(#s(x)) -> c_4() #cklt#(#EQ()) -> c_5() #cklt#(#GT()) -> c_6() #cklt#(#LT()) -> c_7() #compare#(#0(),#0()) -> c_8() #compare#(#0(),#neg(y)) -> c_9() #compare#(#0(),#pos(y)) -> c_10() #compare#(#0(),#s(y)) -> c_11() #compare#(#neg(x),#0()) -> c_12() #compare#(#neg(x),#pos(y)) -> c_14() #compare#(#pos(x),#0()) -> c_15() #compare#(#pos(x),#neg(y)) -> c_16() #compare#(#s(x),#0()) -> c_18() insert#1#(nil(),x) -> c_23() insert#2#(#false(),x,y,ys) -> c_24() insertD#1#(nil(),x) -> c_28() insertD#2#(#false(),x,y,ys) -> c_29() insertionsort#1#(nil()) -> c_33() insertionsortD#1#(nil()) -> c_36() - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/2,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:#compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#s(x),#0()) -> c_18():30 -->_1 #compare#(#pos(x),#neg(y)) -> c_16():29 -->_1 #compare#(#pos(x),#0()) -> c_15():28 -->_1 #compare#(#neg(x),#pos(y)) -> c_14():27 -->_1 #compare#(#neg(x),#0()) -> c_12():26 -->_1 #compare#(#0(),#s(y)) -> c_11():25 -->_1 #compare#(#0(),#pos(y)) -> c_10():24 -->_1 #compare#(#0(),#neg(y)) -> c_9():23 -->_1 #compare#(#0(),#0()) -> c_8():22 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 2:S:#compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#s(x),#0()) -> c_18():30 -->_1 #compare#(#pos(x),#neg(y)) -> c_16():29 -->_1 #compare#(#pos(x),#0()) -> c_15():28 -->_1 #compare#(#neg(x),#pos(y)) -> c_14():27 -->_1 #compare#(#neg(x),#0()) -> c_12():26 -->_1 #compare#(#0(),#s(y)) -> c_11():25 -->_1 #compare#(#0(),#pos(y)) -> c_10():24 -->_1 #compare#(#0(),#neg(y)) -> c_9():23 -->_1 #compare#(#0(),#0()) -> c_8():22 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 3:S:#compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) -->_1 #compare#(#s(x),#0()) -> c_18():30 -->_1 #compare#(#pos(x),#neg(y)) -> c_16():29 -->_1 #compare#(#pos(x),#0()) -> c_15():28 -->_1 #compare#(#neg(x),#pos(y)) -> c_14():27 -->_1 #compare#(#neg(x),#0()) -> c_12():26 -->_1 #compare#(#0(),#s(y)) -> c_11():25 -->_1 #compare#(#0(),#pos(y)) -> c_10():24 -->_1 #compare#(#0(),#neg(y)) -> c_9():23 -->_1 #compare#(#0(),#0()) -> c_8():22 -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 4:S:#less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) -->_2 #compare#(#s(x),#0()) -> c_18():30 -->_2 #compare#(#pos(x),#neg(y)) -> c_16():29 -->_2 #compare#(#pos(x),#0()) -> c_15():28 -->_2 #compare#(#neg(x),#pos(y)) -> c_14():27 -->_2 #compare#(#neg(x),#0()) -> c_12():26 -->_2 #compare#(#0(),#s(y)) -> c_11():25 -->_2 #compare#(#0(),#pos(y)) -> c_10():24 -->_2 #compare#(#0(),#neg(y)) -> c_9():23 -->_2 #compare#(#0(),#0()) -> c_8():22 -->_1 #cklt#(#LT()) -> c_7():21 -->_1 #cklt#(#GT()) -> c_6():20 -->_1 #cklt#(#EQ()) -> c_5():19 -->_2 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_2 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_2 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 5:S:insert#(x,l) -> c_21(insert#1#(l,x)) -->_1 insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)):6 -->_1 insert#1#(nil(),x) -> c_23():31 6:S:insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_1 insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)):7 -->_1 insert#2#(#false(),x,y,ys) -> c_24():32 -->_2 #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)):4 7:S:insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):5 8:S:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)):9 -->_1 insertD#1#(nil(),x) -> c_28():33 9:S:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):10 -->_1 insertD#2#(#false(),x,y,ys) -> c_29():34 -->_2 #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)):4 10:S:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):8 11:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):12 -->_1 insertionsort#1#(nil()) -> c_33():35 12:S:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):11 -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):5 13:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):14 -->_1 insertionsortD#1#(nil()) -> c_36():36 14:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):13 -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):8 15:W:#abs#(#0()) -> c_1() 16:W:#abs#(#neg(x)) -> c_2() 17:W:#abs#(#pos(x)) -> c_3() 18:W:#abs#(#s(x)) -> c_4() 19:W:#cklt#(#EQ()) -> c_5() 20:W:#cklt#(#GT()) -> c_6() 21:W:#cklt#(#LT()) -> c_7() 22:W:#compare#(#0(),#0()) -> c_8() 23:W:#compare#(#0(),#neg(y)) -> c_9() 24:W:#compare#(#0(),#pos(y)) -> c_10() 25:W:#compare#(#0(),#s(y)) -> c_11() 26:W:#compare#(#neg(x),#0()) -> c_12() 27:W:#compare#(#neg(x),#pos(y)) -> c_14() 28:W:#compare#(#pos(x),#0()) -> c_15() 29:W:#compare#(#pos(x),#neg(y)) -> c_16() 30:W:#compare#(#s(x),#0()) -> c_18() 31:W:insert#1#(nil(),x) -> c_23() 32:W:insert#2#(#false(),x,y,ys) -> c_24() 33:W:insertD#1#(nil(),x) -> c_28() 34:W:insertD#2#(#false(),x,y,ys) -> c_29() 35:W:insertionsort#1#(nil()) -> c_33() 36:W:insertionsortD#1#(nil()) -> c_36() The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 18: #abs#(#s(x)) -> c_4() 17: #abs#(#pos(x)) -> c_3() 16: #abs#(#neg(x)) -> c_2() 15: #abs#(#0()) -> c_1() 36: insertionsortD#1#(nil()) -> c_36() 35: insertionsort#1#(nil()) -> c_33() 33: insertD#1#(nil(),x) -> c_28() 34: insertD#2#(#false(),x,y,ys) -> c_29() 31: insert#1#(nil(),x) -> c_23() 32: insert#2#(#false(),x,y,ys) -> c_24() 19: #cklt#(#EQ()) -> c_5() 20: #cklt#(#GT()) -> c_6() 21: #cklt#(#LT()) -> c_7() 22: #compare#(#0(),#0()) -> c_8() 23: #compare#(#0(),#neg(y)) -> c_9() 24: #compare#(#0(),#pos(y)) -> c_10() 25: #compare#(#0(),#s(y)) -> c_11() 26: #compare#(#neg(x),#0()) -> c_12() 27: #compare#(#neg(x),#pos(y)) -> c_14() 28: #compare#(#pos(x),#0()) -> c_15() 29: #compare#(#pos(x),#neg(y)) -> c_16() 30: #compare#(#s(x),#0()) -> c_18() * Step 5: SimplifyRHS WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/2,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:#compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 2:S:#compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 3:S:#compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 4:S:#less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)) -->_2 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_2 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_2 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 5:S:insert#(x,l) -> c_21(insert#1#(l,x)) -->_1 insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)):6 6:S:insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_1 insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)):7 -->_2 #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)):4 7:S:insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):5 8:S:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)):9 9:S:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):10 -->_2 #less#(x,y) -> c_20(#cklt#(#compare(x,y)),#compare#(x,y)):4 10:S:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):8 11:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):12 12:S:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):11 -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):5 13:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):14 14:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):13 -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):8 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: #less#(x,y) -> c_20(#compare#(x,y)) * Step 6: Decompose WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd} + Details: We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component. Problem (R) - Strict DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2 ,#less#/2,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1 ,insertionsort#1#/1,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1 ,#pos/1,#s/1,#true/0,dd/2,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0 ,c_13/1,c_14/0,c_15/0,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2 ,c_28/0,c_29/0,c_30/1,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} Problem (S) - Strict DPs: #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2 ,#less#/2,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1 ,insertionsort#1#/1,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1 ,#pos/1,#s/1,#true/0,dd/2,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0 ,c_13/1,c_14/0,c_15/0,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2 ,c_28/0,c_29/0,c_30/1,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} ** Step 6.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) The strictly oriented rules are moved into the weak component. *** Step 6.a:1.a:1: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(c_13) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1}, uargs(c_20) = {1}, uargs(c_21) = {1}, uargs(c_22) = {1,2}, uargs(c_25) = {1}, uargs(c_26) = {1}, uargs(c_27) = {1,2}, uargs(c_30) = {1}, uargs(c_31) = {1}, uargs(c_32) = {1,2}, uargs(c_34) = {1}, uargs(c_35) = {1,2} Following symbols are considered usable: {insert,insert#1,insert#2,insertD,insertD#1,insertD#2,insertionsort,insertionsort#1,insertionsortD ,insertionsortD#1,#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2#,insertD#,insertD#1#,insertD#2# ,insertionsort#,insertionsort#1#,insertionsortD#,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = 1 p(#EQ) = 1 p(#GT) = 0 p(#LT) = 1 p(#abs) = 0 p(#cklt) = 2*x1 p(#compare) = 2 + x1*x2 + x2 + x2^2 p(#false) = 0 p(#less) = 0 p(#neg) = 1 + x1 p(#pos) = x1 p(#s) = x1 p(#true) = 0 p(dd) = x1 + x2 p(insert) = x1 + x2 p(insert#1) = x1 + x2 p(insert#2) = x2 + x3 + x4 p(insertD) = x1 + x2 p(insertD#1) = x1 + x2 p(insertD#2) = x2 + x3 + x4 p(insertionsort) = x1 p(insertionsort#1) = x1 p(insertionsortD) = 1 + x1 p(insertionsortD#1) = 1 + x1 p(nil) = 0 p(#abs#) = 2 + x1 + x1^2 p(#cklt#) = 1 + x1 + 2*x1^2 p(#compare#) = x1*x2 p(#less#) = x1*x2 p(insert#) = x1*x2 p(insert#1#) = x1*x2 p(insert#2#) = x2*x4 p(insertD#) = 2*x1*x2 p(insertD#1#) = 2*x1*x2 p(insertD#2#) = 2*x2*x4 p(insertionsort#) = 2*x1^2 p(insertionsort#1#) = 2*x1^2 p(insertionsortD#) = 1 + 2*x1 + x1^2 p(insertionsortD#1#) = 1 + 2*x1 + x1^2 p(c_1) = 2 p(c_2) = 1 p(c_3) = 0 p(c_4) = 0 p(c_5) = 1 p(c_6) = 1 p(c_7) = 0 p(c_8) = 2 p(c_9) = 1 p(c_10) = 0 p(c_11) = 0 p(c_12) = 1 p(c_13) = x1 p(c_14) = 0 p(c_15) = 0 p(c_16) = 0 p(c_17) = x1 p(c_18) = 2 p(c_19) = x1 p(c_20) = x1 p(c_21) = x1 p(c_22) = x1 + x2 p(c_23) = 0 p(c_24) = 2 p(c_25) = x1 p(c_26) = x1 p(c_27) = x1 + x2 p(c_28) = 0 p(c_29) = 1 p(c_30) = x1 p(c_31) = x1 p(c_32) = x1 + x2 p(c_33) = 0 p(c_34) = x1 p(c_35) = x1 + x2 p(c_36) = 0 Following rules are strictly oriented: #compare#(#neg(x),#neg(y)) = 1 + x + x*y + y > x*y = c_13(#compare#(y,x)) Following rules are (at-least) weakly oriented: #compare#(#pos(x),#pos(y)) = x*y >= x*y = c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) = x*y >= x*y = c_19(#compare#(x,y)) #less#(x,y) = x*y >= x*y = c_20(#compare#(x,y)) insert#(x,l) = l*x >= l*x = c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) = x*y + x*ys >= x*y + x*ys = c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) = x*ys >= x*ys = c_25(insert#(x,ys)) insertD#(x,l) = 2*l*x >= 2*l*x = c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) = 2*x*y + 2*x*ys >= x*y + 2*x*ys = c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) = 2*x*ys >= 2*x*ys = c_30(insertD#(x,ys)) insertionsort#(l) = 2*l^2 >= 2*l^2 = c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) = 4*x*xs + 2*x^2 + 2*xs^2 >= x*xs + 2*xs^2 = c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) = 1 + 2*l + l^2 >= 1 + 2*l + l^2 = c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) = 1 + 2*x + 2*x*xs + x^2 + 2*xs + xs^2 >= 1 + 2*x + 2*x*xs + 2*xs + xs^2 = c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) insert(x,l) = l + x >= l + x = insert#1(l,x) insert#1(dd(y,ys),x) = x + y + ys >= x + y + ys = insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) = x >= x = dd(x,nil()) insert#2(#false(),x,y,ys) = x + y + ys >= x + y + ys = dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) = x + y + ys >= x + y + ys = dd(y,insert(x,ys)) insertD(x,l) = l + x >= l + x = insertD#1(l,x) insertD#1(dd(y,ys),x) = x + y + ys >= x + y + ys = insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) = x >= x = dd(x,nil()) insertD#2(#false(),x,y,ys) = x + y + ys >= x + y + ys = dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) = x + y + ys >= x + y + ys = dd(y,insertD(x,ys)) insertionsort(l) = l >= l = insertionsort#1(l) insertionsort#1(dd(x,xs)) = x + xs >= x + xs = insert(x,insertionsort(xs)) insertionsort#1(nil()) = 0 >= 0 = nil() insertionsortD(l) = 1 + l >= 1 + l = insertionsortD#1(l) insertionsortD#1(dd(x,xs)) = 1 + x + xs >= 1 + x + xs = insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) = 1 >= 0 = nil() *** Step 6.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () *** Step 6.a:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) The strictly oriented rules are moved into the weak component. **** Step 6.a:1.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(c_13) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1}, uargs(c_20) = {1}, uargs(c_21) = {1}, uargs(c_22) = {1,2}, uargs(c_25) = {1}, uargs(c_26) = {1}, uargs(c_27) = {1,2}, uargs(c_30) = {1}, uargs(c_31) = {1}, uargs(c_32) = {1,2}, uargs(c_34) = {1}, uargs(c_35) = {1,2} Following symbols are considered usable: {insert,insert#1,insert#2,insertD,insertD#1,insertD#2,insertionsort,insertionsort#1,insertionsortD ,insertionsortD#1,#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2#,insertD#,insertD#1#,insertD#2# ,insertionsort#,insertionsort#1#,insertionsortD#,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = 2 p(#EQ) = 0 p(#GT) = 0 p(#LT) = 0 p(#abs) = 0 p(#cklt) = 2 p(#compare) = 0 p(#false) = 0 p(#less) = 0 p(#neg) = x1 p(#pos) = 1 + x1 p(#s) = x1 p(#true) = 0 p(dd) = x1 + x2 p(insert) = x1 + x2 p(insert#1) = x1 + x2 p(insert#2) = x2 + x3 + x4 p(insertD) = x1 + x2 p(insertD#1) = x1 + x2 p(insertD#2) = x2 + x3 + x4 p(insertionsort) = x1 p(insertionsort#1) = x1 p(insertionsortD) = x1 p(insertionsortD#1) = x1 p(nil) = 0 p(#abs#) = 1 + 2*x1 p(#cklt#) = 0 p(#compare#) = 2*x1*x2 p(#less#) = 2*x1*x2 p(insert#) = 3*x1*x2 p(insert#1#) = 3*x1*x2 p(insert#2#) = 3*x2*x4 p(insertD#) = 2*x1*x2 + x1^2 p(insertD#1#) = 2*x1*x2 + x2^2 p(insertD#2#) = 2*x2*x4 + x2^2 p(insertionsort#) = 2*x1 + 2*x1^2 p(insertionsort#1#) = 2*x1 + 2*x1^2 p(insertionsortD#) = x1^2 p(insertionsortD#1#) = x1^2 p(c_1) = 0 p(c_2) = 2 p(c_3) = 0 p(c_4) = 0 p(c_5) = 0 p(c_6) = 2 p(c_7) = 0 p(c_8) = 0 p(c_9) = 0 p(c_10) = 0 p(c_11) = 1 p(c_12) = 0 p(c_13) = x1 p(c_14) = 0 p(c_15) = 1 p(c_16) = 0 p(c_17) = x1 p(c_18) = 2 p(c_19) = x1 p(c_20) = x1 p(c_21) = x1 p(c_22) = x1 + x2 p(c_23) = 0 p(c_24) = 1 p(c_25) = x1 p(c_26) = x1 p(c_27) = x1 + x2 p(c_28) = 0 p(c_29) = 2 p(c_30) = x1 p(c_31) = x1 p(c_32) = x1 + x2 p(c_33) = 1 p(c_34) = x1 p(c_35) = x1 + x2 p(c_36) = 2 Following rules are strictly oriented: #compare#(#pos(x),#pos(y)) = 2 + 2*x + 2*x*y + 2*y > 2*x*y = c_17(#compare#(x,y)) Following rules are (at-least) weakly oriented: #compare#(#neg(x),#neg(y)) = 2*x*y >= 2*x*y = c_13(#compare#(y,x)) #compare#(#s(x),#s(y)) = 2*x*y >= 2*x*y = c_19(#compare#(x,y)) #less#(x,y) = 2*x*y >= 2*x*y = c_20(#compare#(x,y)) insert#(x,l) = 3*l*x >= 3*l*x = c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) = 3*x*y + 3*x*ys >= 2*x*y + 3*x*ys = c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) = 3*x*ys >= 3*x*ys = c_25(insert#(x,ys)) insertD#(x,l) = 2*l*x + x^2 >= 2*l*x + x^2 = c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) = 2*x*y + 2*x*ys + x^2 >= 2*x*y + 2*x*ys + x^2 = c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) = 2*x*ys + x^2 >= 2*x*ys + x^2 = c_30(insertD#(x,ys)) insertionsort#(l) = 2*l + 2*l^2 >= 2*l + 2*l^2 = c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) = 2*x + 4*x*xs + 2*x^2 + 2*xs + 2*xs^2 >= 3*x*xs + 2*xs + 2*xs^2 = c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) = l^2 >= l^2 = c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) = 2*x*xs + x^2 + xs^2 >= 2*x*xs + x^2 + xs^2 = c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) insert(x,l) = l + x >= l + x = insert#1(l,x) insert#1(dd(y,ys),x) = x + y + ys >= x + y + ys = insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) = x >= x = dd(x,nil()) insert#2(#false(),x,y,ys) = x + y + ys >= x + y + ys = dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) = x + y + ys >= x + y + ys = dd(y,insert(x,ys)) insertD(x,l) = l + x >= l + x = insertD#1(l,x) insertD#1(dd(y,ys),x) = x + y + ys >= x + y + ys = insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) = x >= x = dd(x,nil()) insertD#2(#false(),x,y,ys) = x + y + ys >= x + y + ys = dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) = x + y + ys >= x + y + ys = dd(y,insertD(x,ys)) insertionsort(l) = l >= l = insertionsort#1(l) insertionsort#1(dd(x,xs)) = x + xs >= x + xs = insert(x,insertionsort(xs)) insertionsort#1(nil()) = 0 >= 0 = nil() insertionsortD(l) = l >= l = insertionsortD#1(l) insertionsortD#1(dd(x,xs)) = x + xs >= x + xs = insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) = 0 >= 0 = nil() **** Step 6.a:1.b:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () **** Step 6.a:1.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) The strictly oriented rules are moved into the weak component. ***** Step 6.a:1.b:1.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(c_13) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1}, uargs(c_20) = {1}, uargs(c_21) = {1}, uargs(c_22) = {1,2}, uargs(c_25) = {1}, uargs(c_26) = {1}, uargs(c_27) = {1,2}, uargs(c_30) = {1}, uargs(c_31) = {1}, uargs(c_32) = {1,2}, uargs(c_34) = {1}, uargs(c_35) = {1,2} Following symbols are considered usable: {insert,insert#1,insert#2,insertD,insertD#1,insertD#2,insertionsort,insertionsort#1,insertionsortD ,insertionsortD#1,#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2#,insertD#,insertD#1#,insertD#2# ,insertionsort#,insertionsort#1#,insertionsortD#,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = 0 p(#EQ) = 0 p(#GT) = 0 p(#LT) = 0 p(#abs) = 2*x1 + 2*x1^2 p(#cklt) = x1 p(#compare) = 1 + 2*x1*x2 p(#false) = 1 p(#less) = 0 p(#neg) = x1 p(#pos) = x1 p(#s) = 1 + x1 p(#true) = 2 p(dd) = x1 + x2 p(insert) = x1 + x2 p(insert#1) = x1 + x2 p(insert#2) = x2 + x3 + x4 p(insertD) = 2*x1 + x2 p(insertD#1) = x1 + 2*x2 p(insertD#2) = 2*x2 + x3 + x4 p(insertionsort) = 2*x1 p(insertionsort#1) = 2*x1 p(insertionsortD) = 2*x1 p(insertionsortD#1) = 2*x1 p(nil) = 0 p(#abs#) = 2*x1 + 2*x1^2 p(#cklt#) = 2 p(#compare#) = x1*x2 p(#less#) = x1*x2 p(insert#) = x1*x2 + x1^2 p(insert#1#) = x1*x2 + x2^2 p(insert#2#) = x2*x4 + x2^2 p(insertD#) = 3*x1 + x1*x2 p(insertD#1#) = x1*x2 + 3*x2 p(insertD#2#) = 3*x2 + x2*x4 p(insertionsort#) = 1 + x1 + x1^2 p(insertionsort#1#) = 1 + x1 + x1^2 p(insertionsortD#) = 3 + 3*x1 + x1^2 p(insertionsortD#1#) = 3 + 3*x1 + x1^2 p(c_1) = 2 p(c_2) = 0 p(c_3) = 0 p(c_4) = 1 p(c_5) = 0 p(c_6) = 1 p(c_7) = 0 p(c_8) = 0 p(c_9) = 0 p(c_10) = 0 p(c_11) = 0 p(c_12) = 0 p(c_13) = x1 p(c_14) = 2 p(c_15) = 1 p(c_16) = 2 p(c_17) = x1 p(c_18) = 0 p(c_19) = x1 p(c_20) = x1 p(c_21) = x1 p(c_22) = x1 + x2 p(c_23) = 0 p(c_24) = 0 p(c_25) = x1 p(c_26) = x1 p(c_27) = x1 + x2 p(c_28) = 0 p(c_29) = 2 p(c_30) = x1 p(c_31) = x1 p(c_32) = x1 + x2 p(c_33) = 0 p(c_34) = x1 p(c_35) = x1 + x2 p(c_36) = 1 Following rules are strictly oriented: #compare#(#s(x),#s(y)) = 1 + x + x*y + y > x*y = c_19(#compare#(x,y)) Following rules are (at-least) weakly oriented: #compare#(#neg(x),#neg(y)) = x*y >= x*y = c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) = x*y >= x*y = c_17(#compare#(x,y)) #less#(x,y) = x*y >= x*y = c_20(#compare#(x,y)) insert#(x,l) = l*x + x^2 >= l*x + x^2 = c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) = x*y + x*ys + x^2 >= x*y + x*ys + x^2 = c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) = x*ys + x^2 >= x*ys + x^2 = c_25(insert#(x,ys)) insertD#(x,l) = l*x + 3*x >= l*x + 3*x = c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) = 3*x + x*y + x*ys >= 3*x + x*y + x*ys = c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) = 3*x + x*ys >= 3*x + x*ys = c_30(insertD#(x,ys)) insertionsort#(l) = 1 + l + l^2 >= 1 + l + l^2 = c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) = 1 + x + 2*x*xs + x^2 + xs + xs^2 >= 1 + 2*x*xs + x^2 + xs + xs^2 = c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) = 3 + 3*l + l^2 >= 3 + 3*l + l^2 = c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) = 3 + 3*x + 2*x*xs + x^2 + 3*xs + xs^2 >= 3 + 3*x + 2*x*xs + 3*xs + xs^2 = c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) insert(x,l) = l + x >= l + x = insert#1(l,x) insert#1(dd(y,ys),x) = x + y + ys >= x + y + ys = insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) = x >= x = dd(x,nil()) insert#2(#false(),x,y,ys) = x + y + ys >= x + y + ys = dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) = x + y + ys >= x + y + ys = dd(y,insert(x,ys)) insertD(x,l) = l + 2*x >= l + 2*x = insertD#1(l,x) insertD#1(dd(y,ys),x) = 2*x + y + ys >= 2*x + y + ys = insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) = 2*x >= x = dd(x,nil()) insertD#2(#false(),x,y,ys) = 2*x + y + ys >= x + y + ys = dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) = 2*x + y + ys >= 2*x + y + ys = dd(y,insertD(x,ys)) insertionsort(l) = 2*l >= 2*l = insertionsort#1(l) insertionsort#1(dd(x,xs)) = 2*x + 2*xs >= x + 2*xs = insert(x,insertionsort(xs)) insertionsort#1(nil()) = 0 >= 0 = nil() insertionsortD(l) = 2*l >= 2*l = insertionsortD#1(l) insertionsortD#1(dd(x,xs)) = 2*x + 2*xs >= 2*x + 2*xs = insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) = 0 >= 0 = nil() ***** Step 6.a:1.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ***** Step 6.a:1.b:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:#compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 2:W:#compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 3:W:#compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 4:W:#less#(x,y) -> c_20(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):3 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):2 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):1 5:W:insert#(x,l) -> c_21(insert#1#(l,x)) -->_1 insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)):6 6:W:insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_1 insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)):7 -->_2 #less#(x,y) -> c_20(#compare#(x,y)):4 7:W:insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):5 8:W:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)):9 9:W:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):10 -->_2 #less#(x,y) -> c_20(#compare#(x,y)):4 10:W:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):8 11:W:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):12 12:W:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):11 -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):5 13:W:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):14 14:W:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):13 -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):8 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 13: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 14: insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) 11: insertionsort#(l) -> c_31(insertionsort#1#(l)) 12: insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) 8: insertD#(x,l) -> c_26(insertD#1#(l,x)) 10: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) 9: insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) 5: insert#(x,l) -> c_21(insert#1#(l,x)) 7: insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) 6: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) 4: #less#(x,y) -> c_20(#compare#(x,y)) 1: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) 3: #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) 2: #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) ***** Step 6.a:1.b:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). ** Step 6.b:1: PredecessorEstimation WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: #less#(x,y) -> c_20(#compare#(x,y)) insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {1} by application of Pre({1}) = {3,6}. Here rules are labelled as follows: 1: #less#(x,y) -> c_20(#compare#(x,y)) 2: insert#(x,l) -> c_21(insert#1#(l,x)) 3: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) 4: insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) 5: insertD#(x,l) -> c_26(insertD#1#(l,x)) 6: insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) 7: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) 8: insertionsort#(l) -> c_31(insertionsort#1#(l)) 9: insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) 10: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 11: insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) 12: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) 13: #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) 14: #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) ** Step 6.b:2: RemoveWeakSuffixes WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak DPs: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) #less#(x,y) -> c_20(#compare#(x,y)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:insert#(x,l) -> c_21(insert#1#(l,x)) -->_1 insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)):2 2:S:insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_2 #less#(x,y) -> c_20(#compare#(x,y)):14 -->_1 insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)):3 3:S:insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):1 4:S:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)):5 5:S:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_2 #less#(x,y) -> c_20(#compare#(x,y)):14 -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):6 6:S:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):4 7:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):8 8:S:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):7 -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):1 9:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):10 10:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):9 -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):4 11:W:#compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):13 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):12 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):11 12:W:#compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):13 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):12 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):11 13:W:#compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):13 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):12 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):11 14:W:#less#(x,y) -> c_20(#compare#(x,y)) -->_1 #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)):13 -->_1 #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)):12 -->_1 #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)):11 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 14: #less#(x,y) -> c_20(#compare#(x,y)) 13: #compare#(#s(x),#s(y)) -> c_19(#compare#(x,y)) 12: #compare#(#pos(x),#pos(y)) -> c_17(#compare#(x,y)) 11: #compare#(#neg(x),#neg(y)) -> c_13(#compare#(y,x)) ** Step 6.b:3: SimplifyRHS WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/2,c_23/0,c_24/0,c_25/1,c_26/1,c_27/2,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:insert#(x,l) -> c_21(insert#1#(l,x)) -->_1 insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)):2 2:S:insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_1 insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)):3 3:S:insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):1 4:S:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)):5 5:S:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys),#less#(y,x)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):6 6:S:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):4 7:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):8 8:S:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):7 -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):1 9:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):10 10:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):9 -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):4 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) ** Step 6.b:4: Decompose WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd} + Details: We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component. Problem (R) - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) - Weak DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2 ,#less#/2,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1 ,insertionsort#1#/1,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1 ,#pos/1,#s/1,#true/0,dd/2,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0 ,c_13/1,c_14/0,c_15/0,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1 ,c_28/0,c_29/0,c_30/1,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} Problem (S) - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2 ,#less#/2,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1 ,insertionsort#1#/1,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1 ,#pos/1,#s/1,#true/0,dd/2,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0 ,c_13/1,c_14/0,c_15/0,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1 ,c_28/0,c_29/0,c_30/1,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} *** Step 6.b:4.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) - Weak DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:insert#(x,l) -> c_21(insert#1#(l,x)) -->_1 insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)):2 2:S:insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) -->_1 insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)):3 3:S:insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):1 4:W:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)):5 5:W:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):6 6:W:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):4 7:W:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):8 8:W:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):1 -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):7 9:W:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):10 10:W:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):4 -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):9 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 9: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 10: insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) 4: insertD#(x,l) -> c_26(insertD#1#(l,x)) 6: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) 5: insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) *** Step 6.b:4.a:2: UsableRules WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: UsableRules + Details: We replace rewrite rules by usable rules: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) *** Step 6.b:4.a:3: PredecessorEstimationCP WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 2: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) Consider the set of all dependency pairs 1: insert#(x,l) -> c_21(insert#1#(l,x)) 2: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) 3: insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) 4: insertionsort#(l) -> c_31(insertionsort#1#(l)) 5: insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2)) SPACE(?,?)on application of the dependency pairs {2} These cover all (indirect) predecessors of dependency pairs {2,3} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. **** Step 6.b:4.a:3.a:1: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(c_21) = {1}, uargs(c_22) = {1}, uargs(c_25) = {1}, uargs(c_31) = {1}, uargs(c_32) = {1,2} Following symbols are considered usable: {insert,insert#1,insert#2,insertionsort,insertionsort#1,#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD#,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = 0 p(#EQ) = 0 p(#GT) = 0 p(#LT) = 1 p(#abs) = x1^2 p(#cklt) = 2*x1 p(#compare) = x1 + x1*x2 + 2*x2 + x2^2 p(#false) = 0 p(#less) = 0 p(#neg) = 0 p(#pos) = x1 p(#s) = 0 p(#true) = 0 p(dd) = 1 + x1 + x2 p(insert) = 1 + x1 + x2 p(insert#1) = 1 + x1 + x2 p(insert#2) = 2 + x2 + x3 + x4 p(insertD) = 1 + 2*x1 + 2*x1*x2 + 2*x2 p(insertD#1) = 2 + 2*x1 + 2*x1^2 + x2 p(insertD#2) = x1 + x1*x2 + 2*x2^2 + x4 p(insertionsort) = x1 p(insertionsort#1) = x1 p(insertionsortD) = 1 + 2*x1 + x1^2 p(insertionsortD#1) = x1^2 p(nil) = 0 p(#abs#) = 2*x1^2 p(#cklt#) = 0 p(#compare#) = 2 + x1*x2 + x2^2 p(#less#) = 2*x1 + 2*x2 p(insert#) = x2 p(insert#1#) = x1 p(insert#2#) = x3 + x4 p(insertD#) = 2*x1 + 2*x1^2 p(insertD#1#) = x1 + 2*x2 + 2*x2^2 p(insertD#2#) = 2 + x1 + x2 + 2*x2^2 + x3 p(insertionsort#) = 2*x1^2 p(insertionsort#1#) = 2*x1^2 p(insertionsortD#) = 0 p(insertionsortD#1#) = x1 p(c_1) = 0 p(c_2) = 0 p(c_3) = 0 p(c_4) = 1 p(c_5) = 1 p(c_6) = 1 p(c_7) = 2 p(c_8) = 0 p(c_9) = 1 p(c_10) = 0 p(c_11) = 2 p(c_12) = 1 p(c_13) = x1 p(c_14) = 0 p(c_15) = 2 p(c_16) = 0 p(c_17) = x1 p(c_18) = 1 p(c_19) = x1 p(c_20) = 0 p(c_21) = x1 p(c_22) = x1 p(c_23) = 0 p(c_24) = 0 p(c_25) = x1 p(c_26) = 0 p(c_27) = x1 p(c_28) = 0 p(c_29) = 0 p(c_30) = 0 p(c_31) = x1 p(c_32) = x1 + x2 p(c_33) = 2 p(c_34) = 2 + x1 p(c_35) = 0 p(c_36) = 0 Following rules are strictly oriented: insert#1#(dd(y,ys),x) = 1 + y + ys > y + ys = c_22(insert#2#(#less(y,x),x,y,ys)) Following rules are (at-least) weakly oriented: insert#(x,l) = l >= l = c_21(insert#1#(l,x)) insert#2#(#true(),x,y,ys) = y + ys >= ys = c_25(insert#(x,ys)) insertionsort#(l) = 2*l^2 >= 2*l^2 = c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) = 2 + 4*x + 4*x*xs + 2*x^2 + 4*xs + 2*xs^2 >= xs + 2*xs^2 = c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insert(x,l) = 1 + l + x >= 1 + l + x = insert#1(l,x) insert#1(dd(y,ys),x) = 2 + x + y + ys >= 2 + x + y + ys = insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) = 1 + x >= 1 + x = dd(x,nil()) insert#2(#false(),x,y,ys) = 2 + x + y + ys >= 2 + x + y + ys = dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) = 2 + x + y + ys >= 2 + x + y + ys = dd(y,insert(x,ys)) insertionsort(l) = l >= l = insertionsort#1(l) insertionsort#1(dd(x,xs)) = 1 + x + xs >= 1 + x + xs = insert(x,insertionsort(xs)) insertionsort#1(nil()) = 0 >= 0 = nil() **** Step 6.b:4.a:3.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) - Weak DPs: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () **** Step 6.b:4.a:3.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) - Weak DPs: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: insert#(x,l) -> c_21(insert#1#(l,x)) Consider the set of all dependency pairs 1: insert#(x,l) -> c_21(insert#1#(l,x)) 2: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) 3: insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) 4: insertionsort#(l) -> c_31(insertionsort#1#(l)) 5: insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2)) SPACE(?,?)on application of the dependency pairs {1} These cover all (indirect) predecessors of dependency pairs {1,2,3} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. ***** Step 6.b:4.a:3.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insert#(x,l) -> c_21(insert#1#(l,x)) - Weak DPs: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(c_21) = {1}, uargs(c_22) = {1}, uargs(c_25) = {1}, uargs(c_31) = {1}, uargs(c_32) = {1,2} Following symbols are considered usable: {insert,insert#1,insert#2,insertionsort,insertionsort#1,#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD#,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = 0 p(#EQ) = 0 p(#GT) = 0 p(#LT) = 2 p(#abs) = 1 + 2*x1 p(#cklt) = 1 p(#compare) = 2*x2 p(#false) = 0 p(#less) = 0 p(#neg) = 0 p(#pos) = x1 p(#s) = x1 p(#true) = 0 p(dd) = 1 + x1 + x2 p(insert) = 1 + x1 + x2 p(insert#1) = 1 + x1 + x2 p(insert#2) = 2 + x2 + x3 + x4 p(insertD) = x1 + 2*x1^2 + 2*x2 p(insertD#1) = x2 p(insertD#2) = x1*x3 + x2 + x3*x4 + x3^2 p(insertionsort) = x1 p(insertionsort#1) = x1 p(insertionsortD) = 2*x1 p(insertionsortD#1) = 0 p(nil) = 0 p(#abs#) = 2 + 2*x1 p(#cklt#) = 2 + x1 + x1^2 p(#compare#) = 1 + 2*x2^2 p(#less#) = 2 + 2*x1 + 2*x1^2 p(insert#) = 3 + x1 + 2*x1*x2 + 2*x2 p(insert#1#) = 1 + 2*x1 + 2*x1*x2 p(insert#2#) = 3 + x2 + 2*x2*x4 + 2*x4 p(insertD#) = 1 + x1*x2 + x1^2 + x2^2 p(insertD#1#) = x1^2 + 2*x2 + x2^2 p(insertD#2#) = 2 + 2*x1*x2 + x1^2 + 2*x2 + x2*x3 + 2*x3 p(insertionsort#) = 2*x1 + x1^2 p(insertionsort#1#) = 2*x1 + x1^2 p(insertionsortD#) = 0 p(insertionsortD#1#) = 1 p(c_1) = 2 p(c_2) = 0 p(c_3) = 0 p(c_4) = 0 p(c_5) = 0 p(c_6) = 1 p(c_7) = 0 p(c_8) = 2 p(c_9) = 0 p(c_10) = 0 p(c_11) = 0 p(c_12) = 2 p(c_13) = 0 p(c_14) = 0 p(c_15) = 0 p(c_16) = 1 p(c_17) = 0 p(c_18) = 0 p(c_19) = 0 p(c_20) = 2 p(c_21) = 1 + x1 p(c_22) = x1 p(c_23) = 2 p(c_24) = 0 p(c_25) = x1 p(c_26) = 0 p(c_27) = x1 p(c_28) = 2 p(c_29) = 1 p(c_30) = 0 p(c_31) = x1 p(c_32) = x1 + x2 p(c_33) = 0 p(c_34) = 0 p(c_35) = 1 + x2 p(c_36) = 0 Following rules are strictly oriented: insert#(x,l) = 3 + 2*l + 2*l*x + x > 2 + 2*l + 2*l*x = c_21(insert#1#(l,x)) Following rules are (at-least) weakly oriented: insert#1#(dd(y,ys),x) = 3 + 2*x + 2*x*y + 2*x*ys + 2*y + 2*ys >= 3 + x + 2*x*ys + 2*ys = c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) = 3 + x + 2*x*ys + 2*ys >= 3 + x + 2*x*ys + 2*ys = c_25(insert#(x,ys)) insertionsort#(l) = 2*l + l^2 >= 2*l + l^2 = c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) = 3 + 4*x + 2*x*xs + x^2 + 4*xs + xs^2 >= 3 + x + 2*x*xs + 4*xs + xs^2 = c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insert(x,l) = 1 + l + x >= 1 + l + x = insert#1(l,x) insert#1(dd(y,ys),x) = 2 + x + y + ys >= 2 + x + y + ys = insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) = 1 + x >= 1 + x = dd(x,nil()) insert#2(#false(),x,y,ys) = 2 + x + y + ys >= 2 + x + y + ys = dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) = 2 + x + y + ys >= 2 + x + y + ys = dd(y,insert(x,ys)) insertionsort(l) = l >= l = insertionsort#1(l) insertionsort#1(dd(x,xs)) = 1 + x + xs >= 1 + x + xs = insert(x,insertionsort(xs)) insertionsort#1(nil()) = 0 >= 0 = nil() ***** Step 6.b:4.a:3.b:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ***** Step 6.b:4.a:3.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:insert#(x,l) -> c_21(insert#1#(l,x)) -->_1 insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)):2 2:W:insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) -->_1 insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)):3 3:W:insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):1 4:W:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):5 5:W:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):4 -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 4: insertionsort#(l) -> c_31(insertionsort#1#(l)) 5: insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) 1: insert#(x,l) -> c_21(insert#1#(l,x)) 3: insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) 2: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) ***** Step 6.b:4.a:3.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). *** Step 6.b:4.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak DPs: insert#(x,l) -> c_21(insert#1#(l,x)) insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)):2 2:S:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):3 3:S:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):1 4:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):5 5:S:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):8 -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):4 6:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):7 7:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):6 -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):1 8:W:insert#(x,l) -> c_21(insert#1#(l,x)) -->_1 insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)):9 9:W:insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) -->_1 insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)):10 10:W:insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) -->_1 insert#(x,l) -> c_21(insert#1#(l,x)):8 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 8: insert#(x,l) -> c_21(insert#1#(l,x)) 10: insert#2#(#true(),x,y,ys) -> c_25(insert#(x,ys)) 9: insert#1#(dd(y,ys),x) -> c_22(insert#2#(#less(y,x),x,y,ys)) *** Step 6.b:4.b:2: SimplifyRHS WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/2,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)):2 2:S:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):3 3:S:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):1 4:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)):5 5:S:insertionsort#1#(dd(x,xs)) -> c_32(insert#(x,insertionsort(xs)),insertionsort#(xs)) -->_2 insertionsort#(l) -> c_31(insertionsort#1#(l)):4 6:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):7 7:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):6 -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):1 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) *** Step 6.b:4.b:3: UsableRules WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insert(x,l) -> insert#1(l,x) insert#1(dd(y,ys),x) -> insert#2(#less(y,x),x,y,ys) insert#1(nil(),x) -> dd(x,nil()) insert#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insert#2(#true(),x,y,ys) -> dd(y,insert(x,ys)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsort(l) -> insertionsort#1(l) insertionsort#1(dd(x,xs)) -> insert(x,insertionsort(xs)) insertionsort#1(nil()) -> nil() insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: UsableRules + Details: We replace rewrite rules by usable rules: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) *** Step 6.b:4.b:4: Decompose WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd} + Details: We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component. Problem (R) - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2 ,#less#/2,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1 ,insertionsort#1#/1,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1 ,#pos/1,#s/1,#true/0,dd/2,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0 ,c_13/1,c_14/0,c_15/0,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1 ,c_28/0,c_29/0,c_30/1,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} Problem (S) - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2 ,#less#/2,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1 ,insertionsort#1#/1,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1 ,#pos/1,#s/1,#true/0,dd/2,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0 ,c_13/1,c_14/0,c_15/0,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1 ,c_28/0,c_29/0,c_30/1,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} **** Step 6.b:4.b:4.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)):2 2:S:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):3 3:S:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):1 4:W:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)):5 5:W:insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) -->_1 insertionsort#(l) -> c_31(insertionsort#1#(l)):4 6:W:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):7 7:W:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):1 -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):6 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 4: insertionsort#(l) -> c_31(insertionsort#1#(l)) 5: insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) **** Step 6.b:4.b:4.a:2: PredecessorEstimationCP WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) - Weak DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 3: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) The strictly oriented rules are moved into the weak component. ***** Step 6.b:4.b:4.a:2.a:1: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) - Weak DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(c_26) = {1}, uargs(c_27) = {1}, uargs(c_30) = {1}, uargs(c_34) = {1}, uargs(c_35) = {1,2} Following symbols are considered usable: {insertD,insertD#1,insertD#2,insertionsortD,insertionsortD#1,#abs#,#cklt#,#compare#,#less#,insert# ,insert#1#,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = 0 p(#EQ) = 0 p(#GT) = 1 p(#LT) = 0 p(#abs) = 2 p(#cklt) = 1 + 2*x1 p(#compare) = x1*x2 + x1^2 + 2*x2^2 p(#false) = 0 p(#less) = 2*x2^2 p(#neg) = 0 p(#pos) = 0 p(#s) = 0 p(#true) = 0 p(dd) = 1 + x2 p(insert) = 2 + 2*x1*x2 + 2*x2 p(insert#1) = 0 p(insert#2) = 2*x2*x3 + x3^2 p(insertD) = 2 + x2 p(insertD#1) = 2 + x1 p(insertD#2) = 3 + x4 p(insertionsort) = 2 + x1 + 2*x1^2 p(insertionsort#1) = 2*x1^2 p(insertionsortD) = 2*x1 p(insertionsortD#1) = 2*x1 p(nil) = 0 p(#abs#) = 1 p(#cklt#) = 0 p(#compare#) = 1 + 2*x1 p(#less#) = 2*x2 p(insert#) = 1 p(insert#1#) = 2*x1^2 p(insert#2#) = 2*x1 + 2*x1*x4 + x1^2 + 2*x2 + 2*x2*x3 + 2*x2^2 + x3^2 p(insertD#) = 2*x2 p(insertD#1#) = 2*x1 p(insertD#2#) = 1 + 2*x4 p(insertionsort#) = 2 p(insertionsort#1#) = 1 p(insertionsortD#) = 3*x1 + 2*x1^2 p(insertionsortD#1#) = 3*x1 + 2*x1^2 p(c_1) = 2 p(c_2) = 0 p(c_3) = 0 p(c_4) = 0 p(c_5) = 0 p(c_6) = 0 p(c_7) = 0 p(c_8) = 0 p(c_9) = 2 p(c_10) = 1 p(c_11) = 0 p(c_12) = 1 p(c_13) = 0 p(c_14) = 0 p(c_15) = 0 p(c_16) = 1 p(c_17) = 0 p(c_18) = 0 p(c_19) = 0 p(c_20) = x1 p(c_21) = 0 p(c_22) = x1 p(c_23) = 0 p(c_24) = 0 p(c_25) = 0 p(c_26) = x1 p(c_27) = 1 + x1 p(c_28) = 1 p(c_29) = 1 p(c_30) = x1 p(c_31) = 0 p(c_32) = 0 p(c_33) = 0 p(c_34) = x1 p(c_35) = x1 + x2 p(c_36) = 1 Following rules are strictly oriented: insertD#2#(#true(),x,y,ys) = 1 + 2*ys > 2*ys = c_30(insertD#(x,ys)) Following rules are (at-least) weakly oriented: insertD#(x,l) = 2*l >= 2*l = c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) = 2 + 2*ys >= 2 + 2*ys = c_27(insertD#2#(#less(y,x),x,y,ys)) insertionsortD#(l) = 3*l + 2*l^2 >= 3*l + 2*l^2 = c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) = 5 + 7*xs + 2*xs^2 >= 7*xs + 2*xs^2 = c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) insertD(x,l) = 2 + l >= 2 + l = insertD#1(l,x) insertD#1(dd(y,ys),x) = 3 + ys >= 3 + ys = insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) = 2 >= 1 = dd(x,nil()) insertD#2(#false(),x,y,ys) = 3 + ys >= 2 + ys = dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) = 3 + ys >= 3 + ys = dd(y,insertD(x,ys)) insertionsortD(l) = 2*l >= 2*l = insertionsortD#1(l) insertionsortD#1(dd(x,xs)) = 2 + 2*xs >= 2 + 2*xs = insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) = 0 >= 0 = nil() ***** Step 6.b:4.b:4.a:2.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) - Weak DPs: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ***** Step 6.b:4.b:4.a:2.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) - Weak DPs: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: insertD#(x,l) -> c_26(insertD#1#(l,x)) Consider the set of all dependency pairs 1: insertD#(x,l) -> c_26(insertD#1#(l,x)) 2: insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) 3: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) 4: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 5: insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2)) SPACE(?,?)on application of the dependency pairs {1} These cover all (indirect) predecessors of dependency pairs {1,2,3} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. ****** Step 6.b:4.b:4.a:2.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) - Weak DPs: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(c_26) = {1}, uargs(c_27) = {1}, uargs(c_30) = {1}, uargs(c_34) = {1}, uargs(c_35) = {1,2} Following symbols are considered usable: {#cklt,#compare,#less,insertD,insertD#1,insertD#2,insertionsortD,insertionsortD#1,#abs#,#cklt#,#compare# ,#less#,insert#,insert#1#,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1# ,insertionsortD#,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = 2 p(#EQ) = 0 p(#GT) = 0 p(#LT) = 2 p(#abs) = 2*x1^2 p(#cklt) = x1 p(#compare) = x1*x2 p(#false) = 0 p(#less) = x1*x2 p(#neg) = 1 + x1 p(#pos) = 2 + x1 p(#s) = 2 + x1 p(#true) = 2 p(dd) = 1 + x1 + x2 p(insert) = 1 + x1^2 + 2*x2^2 p(insert#1) = 1 + 2*x1 + 2*x1*x2 p(insert#2) = 2*x1*x3 + 2*x2*x3 + 2*x2*x4 + 2*x4^2 p(insertD) = 2 + x1 + x2 p(insertD#1) = 2 + x1 + x2 p(insertD#2) = 3 + x2 + x3 + x4 p(insertionsort) = 2 + x1 p(insertionsort#1) = 2*x1^2 p(insertionsortD) = 2*x1 p(insertionsortD#1) = 2*x1 p(nil) = 2 p(#abs#) = 2 + 2*x1 p(#cklt#) = 0 p(#compare#) = 2 + 2*x1 + 2*x1^2 p(#less#) = x1^2 + x2^2 p(insert#) = 0 p(insert#1#) = x1 + 2*x1*x2 + x2 p(insert#2#) = 2*x1 + x1^2 + x2 + 2*x2*x4 + 2*x2^2 + 2*x3*x4 + 2*x3^2 p(insertD#) = 3 + 2*x1*x2 + 2*x1^2 p(insertD#1#) = 2 + 2*x1*x2 + 2*x2^2 p(insertD#2#) = 2 + 2*x1 + 2*x2*x4 + 2*x2^2 p(insertionsort#) = 2*x1 + x1^2 p(insertionsort#1#) = 0 p(insertionsortD#) = 2*x1 + 2*x1^2 p(insertionsortD#1#) = x1 + 2*x1^2 p(c_1) = 1 p(c_2) = 2 p(c_3) = 0 p(c_4) = 0 p(c_5) = 0 p(c_6) = 0 p(c_7) = 2 p(c_8) = 0 p(c_9) = 2 p(c_10) = 0 p(c_11) = 0 p(c_12) = 0 p(c_13) = 1 p(c_14) = 2 p(c_15) = 0 p(c_16) = 0 p(c_17) = 0 p(c_18) = 0 p(c_19) = 0 p(c_20) = 0 p(c_21) = 2 + x1 p(c_22) = 0 p(c_23) = 0 p(c_24) = 1 p(c_25) = 0 p(c_26) = x1 p(c_27) = x1 p(c_28) = 1 p(c_29) = 0 p(c_30) = x1 p(c_31) = 1 p(c_32) = 0 p(c_33) = 0 p(c_34) = x1 p(c_35) = x1 + x2 p(c_36) = 0 Following rules are strictly oriented: insertD#(x,l) = 3 + 2*l*x + 2*x^2 > 2 + 2*l*x + 2*x^2 = c_26(insertD#1#(l,x)) Following rules are (at-least) weakly oriented: insertD#1#(dd(y,ys),x) = 2 + 2*x + 2*x*y + 2*x*ys + 2*x^2 >= 2 + 2*x*y + 2*x*ys + 2*x^2 = c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) = 6 + 2*x*ys + 2*x^2 >= 3 + 2*x*ys + 2*x^2 = c_30(insertD#(x,ys)) insertionsortD#(l) = 2*l + 2*l^2 >= l + 2*l^2 = c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) = 3 + 5*x + 4*x*xs + 2*x^2 + 5*xs + 2*xs^2 >= 3 + 4*x*xs + 2*x^2 + 2*xs + 2*xs^2 = c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) #cklt(#EQ()) = 0 >= 0 = #false() #cklt(#GT()) = 0 >= 0 = #false() #cklt(#LT()) = 2 >= 2 = #true() #compare(#0(),#0()) = 4 >= 0 = #EQ() #compare(#0(),#neg(y)) = 2 + 2*y >= 0 = #GT() #compare(#0(),#pos(y)) = 4 + 2*y >= 2 = #LT() #compare(#0(),#s(y)) = 4 + 2*y >= 2 = #LT() #compare(#neg(x),#0()) = 2 + 2*x >= 2 = #LT() #compare(#neg(x),#neg(y)) = 1 + x + x*y + y >= x*y = #compare(y,x) #compare(#neg(x),#pos(y)) = 2 + 2*x + x*y + y >= 2 = #LT() #compare(#pos(x),#0()) = 4 + 2*x >= 0 = #GT() #compare(#pos(x),#neg(y)) = 2 + x + x*y + 2*y >= 0 = #GT() #compare(#pos(x),#pos(y)) = 4 + 2*x + x*y + 2*y >= x*y = #compare(x,y) #compare(#s(x),#0()) = 4 + 2*x >= 0 = #GT() #compare(#s(x),#s(y)) = 4 + 2*x + x*y + 2*y >= x*y = #compare(x,y) #less(x,y) = x*y >= x*y = #cklt(#compare(x,y)) insertD(x,l) = 2 + l + x >= 2 + l + x = insertD#1(l,x) insertD#1(dd(y,ys),x) = 3 + x + y + ys >= 3 + x + y + ys = insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) = 4 + x >= 3 + x = dd(x,nil()) insertD#2(#false(),x,y,ys) = 3 + x + y + ys >= 2 + x + y + ys = dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) = 3 + x + y + ys >= 3 + x + y + ys = dd(y,insertD(x,ys)) insertionsortD(l) = 2*l >= 2*l = insertionsortD#1(l) insertionsortD#1(dd(x,xs)) = 2 + 2*x + 2*xs >= 2 + x + 2*xs = insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) = 4 >= 2 = nil() ****** Step 6.b:4.b:4.a:2.b:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) - Weak DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ****** Step 6.b:4.b:4.a:2.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)):2 2:W:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):3 3:W:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):1 4:W:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):5 5:W:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):4 -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 4: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 5: insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) 1: insertD#(x,l) -> c_26(insertD#1#(l,x)) 3: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) 2: insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) ****** Step 6.b:4.b:4.a:2.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). **** Step 6.b:4.b:4.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak DPs: insertD#(x,l) -> c_26(insertD#1#(l,x)) insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)):2 2:S:insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) -->_1 insertionsort#(l) -> c_31(insertionsort#1#(l)):1 3:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):4 4:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):5 -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):3 5:W:insertD#(x,l) -> c_26(insertD#1#(l,x)) -->_1 insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)):6 6:W:insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) -->_1 insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)):7 7:W:insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) -->_1 insertD#(x,l) -> c_26(insertD#1#(l,x)):5 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 5: insertD#(x,l) -> c_26(insertD#1#(l,x)) 7: insertD#2#(#true(),x,y,ys) -> c_30(insertD#(x,ys)) 6: insertD#1#(dd(y,ys),x) -> c_27(insertD#2#(#less(y,x),x,y,ys)) **** Step 6.b:4.b:4.b:2: SimplifyRHS WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/2,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)):2 2:S:insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) -->_1 insertionsort#(l) -> c_31(insertionsort#1#(l)):1 3:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)):4 4:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertD#(x,insertionsortD(xs)),insertionsortD#(xs)) -->_2 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):3 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) **** Step 6.b:4.b:4.b:3: UsableRules WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Weak TRS: #cklt(#EQ()) -> #false() #cklt(#GT()) -> #false() #cklt(#LT()) -> #true() #compare(#0(),#0()) -> #EQ() #compare(#0(),#neg(y)) -> #GT() #compare(#0(),#pos(y)) -> #LT() #compare(#0(),#s(y)) -> #LT() #compare(#neg(x),#0()) -> #LT() #compare(#neg(x),#neg(y)) -> #compare(y,x) #compare(#neg(x),#pos(y)) -> #LT() #compare(#pos(x),#0()) -> #GT() #compare(#pos(x),#neg(y)) -> #GT() #compare(#pos(x),#pos(y)) -> #compare(x,y) #compare(#s(x),#0()) -> #GT() #compare(#s(x),#s(y)) -> #compare(x,y) #less(x,y) -> #cklt(#compare(x,y)) insertD(x,l) -> insertD#1(l,x) insertD#1(dd(y,ys),x) -> insertD#2(#less(y,x),x,y,ys) insertD#1(nil(),x) -> dd(x,nil()) insertD#2(#false(),x,y,ys) -> dd(x,dd(y,ys)) insertD#2(#true(),x,y,ys) -> dd(y,insertD(x,ys)) insertionsortD(l) -> insertionsortD#1(l) insertionsortD#1(dd(x,xs)) -> insertD(x,insertionsortD(xs)) insertionsortD#1(nil()) -> nil() - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: UsableRules + Details: We replace rewrite rules by usable rules: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) **** Step 6.b:4.b:4.b:4: Decompose WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd} + Details: We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component. Problem (R) - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) - Weak DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2 ,#less#/2,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1 ,insertionsort#1#/1,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1 ,#pos/1,#s/1,#true/0,dd/2,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0 ,c_13/1,c_14/0,c_15/0,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1 ,c_28/0,c_29/0,c_30/1,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} Problem (S) - Strict DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2 ,#less#/2,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1 ,insertionsort#1#/1,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1 ,#pos/1,#s/1,#true/0,dd/2,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0 ,c_13/1,c_14/0,c_15/0,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1 ,c_28/0,c_29/0,c_30/1,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1# ,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} ***** Step 6.b:4.b:4.b:4.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) - Weak DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)):2 2:S:insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) -->_1 insertionsort#(l) -> c_31(insertionsort#1#(l)):1 3:W:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)):4 4:W:insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) -->_1 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):3 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 3: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 4: insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) ***** Step 6.b:4.b:4.b:4.a:2: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: insertionsort#(l) -> c_31(insertionsort#1#(l)) Consider the set of all dependency pairs 1: insertionsort#(l) -> c_31(insertionsort#1#(l)) 2: insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1)) SPACE(?,?)on application of the dependency pairs {1} These cover all (indirect) predecessors of dependency pairs {1,2} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. ****** Step 6.b:4.b:4.b:4.a:2.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_31) = {1}, uargs(c_32) = {1} Following symbols are considered usable: {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort# ,insertionsort#1#,insertionsortD#,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = [0] p(#EQ) = [1] p(#GT) = [1] p(#LT) = [2] p(#abs) = [2] x1 + [1] p(#cklt) = [4] x1 + [4] p(#compare) = [2] x1 + [2] p(#false) = [1] p(#less) = [1] x1 + [8] x2 + [1] p(#neg) = [1] x1 + [0] p(#pos) = [1] x1 + [0] p(#s) = [4] p(#true) = [1] p(dd) = [1] x1 + [1] x2 + [2] p(insert) = [4] x1 + [1] x2 + [0] p(insert#1) = [2] x1 + [0] p(insert#2) = [2] x1 + [1] x2 + [1] x3 + [2] p(insertD) = [0] p(insertD#1) = [0] p(insertD#2) = [0] p(insertionsort) = [0] p(insertionsort#1) = [0] p(insertionsortD) = [0] p(insertionsortD#1) = [0] p(nil) = [0] p(#abs#) = [0] p(#cklt#) = [0] p(#compare#) = [0] p(#less#) = [0] p(insert#) = [0] p(insert#1#) = [1] x2 + [0] p(insert#2#) = [1] x3 + [2] p(insertD#) = [1] x1 + [0] p(insertD#1#) = [1] p(insertD#2#) = [4] x1 + [1] p(insertionsort#) = [2] x1 + [4] p(insertionsort#1#) = [2] x1 + [0] p(insertionsortD#) = [2] x1 + [1] p(insertionsortD#1#) = [8] p(c_1) = [2] p(c_2) = [0] p(c_3) = [8] p(c_4) = [0] p(c_5) = [2] p(c_6) = [1] p(c_7) = [2] p(c_8) = [1] p(c_9) = [2] p(c_10) = [0] p(c_11) = [0] p(c_12) = [1] p(c_13) = [1] p(c_14) = [4] p(c_15) = [0] p(c_16) = [2] p(c_17) = [1] x1 + [4] p(c_18) = [2] p(c_19) = [2] p(c_20) = [0] p(c_21) = [1] p(c_22) = [0] p(c_23) = [1] p(c_24) = [2] p(c_25) = [2] p(c_26) = [1] p(c_27) = [2] x1 + [8] p(c_28) = [8] p(c_29) = [2] p(c_30) = [0] p(c_31) = [1] x1 + [2] p(c_32) = [1] x1 + [0] p(c_33) = [2] p(c_34) = [1] x1 + [1] p(c_35) = [8] x1 + [1] p(c_36) = [8] Following rules are strictly oriented: insertionsort#(l) = [2] l + [4] > [2] l + [2] = c_31(insertionsort#1#(l)) Following rules are (at-least) weakly oriented: insertionsort#1#(dd(x,xs)) = [2] x + [2] xs + [4] >= [2] xs + [4] = c_32(insertionsort#(xs)) ****** Step 6.b:4.b:4.b:4.a:2.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ****** Step 6.b:4.b:4.b:4.a:2.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)):2 2:W:insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) -->_1 insertionsort#(l) -> c_31(insertionsort#1#(l)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 1: insertionsort#(l) -> c_31(insertionsort#1#(l)) 2: insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) ****** Step 6.b:4.b:4.b:4.a:2.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). ***** Step 6.b:4.b:4.b:4.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Weak DPs: insertionsort#(l) -> c_31(insertionsort#1#(l)) insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)):2 2:S:insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) -->_1 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):1 3:W:insertionsort#(l) -> c_31(insertionsort#1#(l)) -->_1 insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)):4 4:W:insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) -->_1 insertionsort#(l) -> c_31(insertionsort#1#(l)):3 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 3: insertionsort#(l) -> c_31(insertionsort#1#(l)) 4: insertionsort#1#(dd(x,xs)) -> c_32(insertionsort#(xs)) ***** Step 6.b:4.b:4.b:4.b:2: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 2: insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) The strictly oriented rules are moved into the weak component. ****** Step 6.b:4.b:4.b:4.b:2.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_34) = {1}, uargs(c_35) = {1} Following symbols are considered usable: {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2#,insertD#,insertD#1#,insertD#2#,insertionsort# ,insertionsort#1#,insertionsortD#,insertionsortD#1#} TcT has computed the following interpretation: p(#0) = [0] p(#EQ) = [0] p(#GT) = [0] p(#LT) = [0] p(#abs) = [0] p(#cklt) = [1] x1 + [1] p(#compare) = [1] x1 + [0] p(#false) = [1] p(#less) = [1] x1 + [1] x2 + [2] p(#neg) = [1] x1 + [2] p(#pos) = [1] p(#s) = [1] p(#true) = [0] p(dd) = [1] x2 + [2] p(insert) = [2] x2 + [1] p(insert#1) = [1] x2 + [1] p(insert#2) = [1] x1 + [1] x3 + [1] p(insertD) = [0] p(insertD#1) = [0] p(insertD#2) = [0] p(insertionsort) = [0] p(insertionsort#1) = [0] p(insertionsortD) = [0] p(insertionsortD#1) = [0] p(nil) = [0] p(#abs#) = [0] p(#cklt#) = [0] p(#compare#) = [0] p(#less#) = [0] p(insert#) = [0] p(insert#1#) = [0] p(insert#2#) = [1] x2 + [1] x3 + [8] x4 + [0] p(insertD#) = [1] x1 + [0] p(insertD#1#) = [1] x1 + [2] x2 + [0] p(insertD#2#) = [8] x1 + [8] x2 + [1] x3 + [0] p(insertionsort#) = [2] x1 + [4] p(insertionsort#1#) = [8] x1 + [4] p(insertionsortD#) = [9] x1 + [2] p(insertionsortD#1#) = [9] x1 + [0] p(c_1) = [1] p(c_2) = [1] p(c_3) = [8] p(c_4) = [0] p(c_5) = [2] p(c_6) = [4] p(c_7) = [0] p(c_8) = [2] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [1] p(c_13) = [8] x1 + [0] p(c_14) = [0] p(c_15) = [4] p(c_16) = [1] p(c_17) = [2] x1 + [1] p(c_18) = [1] p(c_19) = [1] p(c_20) = [8] x1 + [0] p(c_21) = [0] p(c_22) = [2] x1 + [0] p(c_23) = [0] p(c_24) = [2] p(c_25) = [1] x1 + [4] p(c_26) = [0] p(c_27) = [1] x1 + [1] p(c_28) = [1] p(c_29) = [1] p(c_30) = [2] x1 + [2] p(c_31) = [1] p(c_32) = [4] x1 + [0] p(c_33) = [8] p(c_34) = [1] x1 + [1] p(c_35) = [1] x1 + [15] p(c_36) = [0] Following rules are strictly oriented: insertionsortD#(l) = [9] l + [2] > [9] l + [1] = c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) = [9] xs + [18] > [9] xs + [17] = c_35(insertionsortD#(xs)) Following rules are (at-least) weakly oriented: ****** Step 6.b:4.b:4.b:4.b:2.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ****** Step 6.b:4.b:4.b:4.b:2.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:insertionsortD#(l) -> c_34(insertionsortD#1#(l)) -->_1 insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)):2 2:W:insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) -->_1 insertionsortD#(l) -> c_34(insertionsortD#1#(l)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 1: insertionsortD#(l) -> c_34(insertionsortD#1#(l)) 2: insertionsortD#1#(dd(x,xs)) -> c_35(insertionsortD#(xs)) ****** Step 6.b:4.b:4.b:4.b:2.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Signature: {#abs/1,#cklt/1,#compare/2,#less/2,insert/2,insert#1/2,insert#2/4,insertD/2,insertD#1/2,insertD#2/4 ,insertionsort/1,insertionsort#1/1,insertionsortD/1,insertionsortD#1/1,#abs#/1,#cklt#/1,#compare#/2,#less#/2 ,insert#/2,insert#1#/2,insert#2#/4,insertD#/2,insertD#1#/2,insertD#2#/4,insertionsort#/1,insertionsort#1#/1 ,insertionsortD#/1,insertionsortD#1#/1} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,dd/2 ,nil/0,c_1/0,c_2/0,c_3/0,c_4/0,c_5/0,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0,c_12/0,c_13/1,c_14/0,c_15/0 ,c_16/0,c_17/1,c_18/0,c_19/1,c_20/1,c_21/1,c_22/1,c_23/0,c_24/0,c_25/1,c_26/1,c_27/1,c_28/0,c_29/0,c_30/1 ,c_31/1,c_32/1,c_33/0,c_34/1,c_35/1,c_36/0} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#cklt#,#compare#,#less#,insert#,insert#1#,insert#2# ,insertD#,insertD#1#,insertD#2#,insertionsort#,insertionsort#1#,insertionsortD# ,insertionsortD#1#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). WORST_CASE(?,O(n^2))