/export/starexec/sandbox/solver/bin/starexec_run_tct_rci /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- WORST_CASE(?,O(n^2)) * Step 1: Sum. 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)) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) testQuicksort(@x) -> quicksort(testList(#unit())) testQuicksort2(@x) -> quicksort(testList(#unit())) - Weak TRS: #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1} / {#0/0,#EQ/0,#GT/0,#LT/0 ,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2} - Obligation: innermost runtime complexity wrt. defined symbols {#abs,#ckgt,#compare,#greater,append,append#1,appendD ,appendD#1,quicksort,quicksort#1,quicksort#2,quicksortD,quicksortD#1,quicksortD#2,split,split#1,split#2 ,split#3,splitD,splitD#1,splitD#2,splitD#3,testList,testQuicksort,testQuicksort2} and constructors {#0,#EQ ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: Sum {left = someStrategy, right = someStrategy} + Details: () * Step 2: 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)) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) testQuicksort(@x) -> quicksort(testList(#unit())) testQuicksort2(@x) -> quicksort(testList(#unit())) - Weak TRS: #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1} / {#0/0,#EQ/0,#GT/0,#LT/0 ,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2} - Obligation: innermost runtime complexity wrt. defined symbols {#abs,#ckgt,#compare,#greater,append,append#1,appendD ,appendD#1,quicksort,quicksort#1,quicksort#2,quicksortD,quicksortD#1,quicksortD#2,split,split#1,split#2 ,split#3,splitD,splitD#1,splitD#2,splitD#3,testList,testQuicksort,testQuicksort2} and constructors {#0,#EQ ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + 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() #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)) append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) append#1#(nil(),@ys) -> c_8() appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) appendD#1#(nil(),@ys) -> c_11() quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#1#(nil()) -> c_14() quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#1#(nil()) -> c_18() quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) split#1#(nil(),@pivot) -> c_22() split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x),#greater#(@x,@pivot)) split#3#(#false(),@ls,@rs,@x) -> c_24() split#3#(#true(),@ls,@rs,@x) -> c_25() splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) splitD#1#(nil(),@pivot) -> c_28() splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) splitD#3#(#false(),@ls,@rs,@x) -> c_30() splitD#3#(#true(),@ls,@rs,@x) -> c_31() testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) Weak DPs #ckgt#(#EQ()) -> c_35() #ckgt#(#GT()) -> c_36() #ckgt#(#LT()) -> c_37() #compare#(#0(),#0()) -> c_38() #compare#(#0(),#neg(@y)) -> c_39() #compare#(#0(),#pos(@y)) -> c_40() #compare#(#0(),#s(@y)) -> c_41() #compare#(#neg(@x),#0()) -> c_42() #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)) #compare#(#neg(@x),#pos(@y)) -> c_44() #compare#(#pos(@x),#0()) -> c_45() #compare#(#pos(@x),#neg(@y)) -> c_46() #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)) #compare#(#s(@x),#0()) -> c_48() #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)) and mark the set of starting terms. * 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() #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)) append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) append#1#(nil(),@ys) -> c_8() appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) appendD#1#(nil(),@ys) -> c_11() quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#1#(nil()) -> c_14() quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#1#(nil()) -> c_18() quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) split#1#(nil(),@pivot) -> c_22() split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x),#greater#(@x,@pivot)) split#3#(#false(),@ls,@rs,@x) -> c_24() split#3#(#true(),@ls,@rs,@x) -> c_25() splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) splitD#1#(nil(),@pivot) -> c_28() splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) splitD#3#(#false(),@ls,@rs,@x) -> c_30() splitD#3#(#true(),@ls,@rs,@x) -> c_31() testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) - Weak DPs: #ckgt#(#EQ()) -> c_35() #ckgt#(#GT()) -> c_36() #ckgt#(#LT()) -> c_37() #compare#(#0(),#0()) -> c_38() #compare#(#0(),#neg(@y)) -> c_39() #compare#(#0(),#pos(@y)) -> c_40() #compare#(#0(),#s(@y)) -> c_41() #compare#(#neg(@x),#0()) -> c_42() #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)) #compare#(#neg(@x),#pos(@y)) -> c_44() #compare#(#pos(@x),#0()) -> c_45() #compare#(#pos(@x),#neg(@y)) -> c_46() #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)) #compare#(#s(@x),#0()) -> c_48() #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)) - Weak TRS: #abs(#0()) -> #0() #abs(#neg(@x)) -> #pos(@x) #abs(#pos(@x)) -> #pos(@x) #abs(#s(@x)) -> #pos(#s(@x)) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) testQuicksort(@x) -> quicksort(testList(#unit())) testQuicksort2(@x) -> quicksort(testList(#unit())) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/2 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/2,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/2,c_34/2,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {1,2,3,4,5,8,11,14,18,22,24,25,28,30,31} by application of Pre({1,2,3,4,5,8,11,14,18,22,24,25,28,30,31}) = {6,9,12,16,20,23,26,29,32}. 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: #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)) 6: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) 7: append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) 8: append#1#(nil(),@ys) -> c_8() 9: appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) 10: appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) 11: appendD#1#(nil(),@ys) -> c_11() 12: quicksort#(@l) -> c_12(quicksort#1#(@l)) 13: quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) 14: quicksort#1#(nil()) -> c_14() 15: quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) 16: quicksortD#(@l) -> c_16(quicksortD#1#(@l)) 17: quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) 18: quicksortD#1#(nil()) -> c_18() 19: quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) 20: split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) 21: split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) 22: split#1#(nil(),@pivot) -> c_22() 23: split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) 24: split#3#(#false(),@ls,@rs,@x) -> c_24() 25: split#3#(#true(),@ls,@rs,@x) -> c_25() 26: splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) 27: splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) 28: splitD#1#(nil(),@pivot) -> c_28() 29: splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) 30: splitD#3#(#false(),@ls,@rs,@x) -> c_30() 31: splitD#3#(#true(),@ls,@rs,@x) -> c_31() 32: testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))) 33: testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) 34: testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) 35: #ckgt#(#EQ()) -> c_35() 36: #ckgt#(#GT()) -> c_36() 37: #ckgt#(#LT()) -> c_37() 38: #compare#(#0(),#0()) -> c_38() 39: #compare#(#0(),#neg(@y)) -> c_39() 40: #compare#(#0(),#pos(@y)) -> c_40() 41: #compare#(#0(),#s(@y)) -> c_41() 42: #compare#(#neg(@x),#0()) -> c_42() 43: #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)) 44: #compare#(#neg(@x),#pos(@y)) -> c_44() 45: #compare#(#pos(@x),#0()) -> c_45() 46: #compare#(#pos(@x),#neg(@y)) -> c_46() 47: #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)) 48: #compare#(#s(@x),#0()) -> c_48() 49: #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)) * Step 4: PredecessorEstimation. WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x),#greater#(@x,@pivot)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) - Weak DPs: #abs#(#0()) -> c_1() #abs#(#neg(@x)) -> c_2() #abs#(#pos(@x)) -> c_3() #abs#(#s(@x)) -> c_4() #ckgt#(#EQ()) -> c_35() #ckgt#(#GT()) -> c_36() #ckgt#(#LT()) -> c_37() #compare#(#0(),#0()) -> c_38() #compare#(#0(),#neg(@y)) -> c_39() #compare#(#0(),#pos(@y)) -> c_40() #compare#(#0(),#s(@y)) -> c_41() #compare#(#neg(@x),#0()) -> c_42() #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)) #compare#(#neg(@x),#pos(@y)) -> c_44() #compare#(#pos(@x),#0()) -> c_45() #compare#(#pos(@x),#neg(@y)) -> c_46() #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)) #compare#(#s(@x),#0()) -> c_48() #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)) #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)) append#1#(nil(),@ys) -> c_8() appendD#1#(nil(),@ys) -> c_11() quicksort#1#(nil()) -> c_14() quicksortD#1#(nil()) -> c_18() split#1#(nil(),@pivot) -> c_22() split#3#(#false(),@ls,@rs,@x) -> c_24() split#3#(#true(),@ls,@rs,@x) -> c_25() splitD#1#(nil(),@pivot) -> c_28() splitD#3#(#false(),@ls,@rs,@x) -> c_30() splitD#3#(#true(),@ls,@rs,@x) -> c_31() - Weak TRS: #abs(#0()) -> #0() #abs(#neg(@x)) -> #pos(@x) #abs(#pos(@x)) -> #pos(@x) #abs(#s(@x)) -> #pos(#s(@x)) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) testQuicksort(@x) -> quicksort(testList(#unit())) testQuicksort2(@x) -> quicksort(testList(#unit())) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/2 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/2,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/2,c_34/2,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {13,16,17} by application of Pre({13,16,17}) = {12,15,18,19}. Here rules are labelled as follows: 1: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) 2: append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) 3: appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) 4: appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) 5: quicksort#(@l) -> c_12(quicksort#1#(@l)) 6: quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) 7: quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) 8: quicksortD#(@l) -> c_16(quicksortD#1#(@l)) 9: quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) 10: quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) 11: split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) 12: split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) 13: split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) 14: splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) 15: splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) 16: splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) 17: testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))) 18: testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) 19: testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) 20: #abs#(#0()) -> c_1() 21: #abs#(#neg(@x)) -> c_2() 22: #abs#(#pos(@x)) -> c_3() 23: #abs#(#s(@x)) -> c_4() 24: #ckgt#(#EQ()) -> c_35() 25: #ckgt#(#GT()) -> c_36() 26: #ckgt#(#LT()) -> c_37() 27: #compare#(#0(),#0()) -> c_38() 28: #compare#(#0(),#neg(@y)) -> c_39() 29: #compare#(#0(),#pos(@y)) -> c_40() 30: #compare#(#0(),#s(@y)) -> c_41() 31: #compare#(#neg(@x),#0()) -> c_42() 32: #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)) 33: #compare#(#neg(@x),#pos(@y)) -> c_44() 34: #compare#(#pos(@x),#0()) -> c_45() 35: #compare#(#pos(@x),#neg(@y)) -> c_46() 36: #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)) 37: #compare#(#s(@x),#0()) -> c_48() 38: #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)) 39: #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)) 40: append#1#(nil(),@ys) -> c_8() 41: appendD#1#(nil(),@ys) -> c_11() 42: quicksort#1#(nil()) -> c_14() 43: quicksortD#1#(nil()) -> c_18() 44: split#1#(nil(),@pivot) -> c_22() 45: split#3#(#false(),@ls,@rs,@x) -> c_24() 46: split#3#(#true(),@ls,@rs,@x) -> c_25() 47: splitD#1#(nil(),@pivot) -> c_28() 48: splitD#3#(#false(),@ls,@rs,@x) -> c_30() 49: splitD#3#(#true(),@ls,@rs,@x) -> c_31() * Step 5: RemoveWeakSuffixes. WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) - Weak DPs: #abs#(#0()) -> c_1() #abs#(#neg(@x)) -> c_2() #abs#(#pos(@x)) -> c_3() #abs#(#s(@x)) -> c_4() #ckgt#(#EQ()) -> c_35() #ckgt#(#GT()) -> c_36() #ckgt#(#LT()) -> c_37() #compare#(#0(),#0()) -> c_38() #compare#(#0(),#neg(@y)) -> c_39() #compare#(#0(),#pos(@y)) -> c_40() #compare#(#0(),#s(@y)) -> c_41() #compare#(#neg(@x),#0()) -> c_42() #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)) #compare#(#neg(@x),#pos(@y)) -> c_44() #compare#(#pos(@x),#0()) -> c_45() #compare#(#pos(@x),#neg(@y)) -> c_46() #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)) #compare#(#s(@x),#0()) -> c_48() #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)) #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)) append#1#(nil(),@ys) -> c_8() appendD#1#(nil(),@ys) -> c_11() quicksort#1#(nil()) -> c_14() quicksortD#1#(nil()) -> c_18() split#1#(nil(),@pivot) -> c_22() split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x),#greater#(@x,@pivot)) split#3#(#false(),@ls,@rs,@x) -> c_24() split#3#(#true(),@ls,@rs,@x) -> c_25() splitD#1#(nil(),@pivot) -> c_28() splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) splitD#3#(#false(),@ls,@rs,@x) -> c_30() splitD#3#(#true(),@ls,@rs,@x) -> c_31() testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))) - Weak TRS: #abs(#0()) -> #0() #abs(#neg(@x)) -> #pos(@x) #abs(#pos(@x)) -> #pos(@x) #abs(#s(@x)) -> #pos(#s(@x)) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) testQuicksort(@x) -> quicksort(testList(#unit())) testQuicksort2(@x) -> quicksort(testList(#unit())) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/2 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/2,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/2,c_34/2,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:append#(@l,@ys) -> c_6(append#1#(@l,@ys)) -->_1 append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)):2 -->_1 append#1#(nil(),@ys) -> c_8():37 2:S:append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) -->_1 append#(@l,@ys) -> c_6(append#1#(@l,@ys)):1 3:S:appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) -->_1 appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)):4 -->_1 appendD#1#(nil(),@ys) -> c_11():38 4:S:appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) -->_1 appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)):3 5:S:quicksort#(@l) -> c_12(quicksort#1#(@l)) -->_1 quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)):6 -->_1 quicksort#1#(nil()) -> c_14():39 6:S:quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) -->_2 split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)):11 -->_1 quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)):7 7:S:quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) -->_3 quicksort#(@l) -> c_12(quicksort#1#(@l)):5 -->_2 quicksort#(@l) -> c_12(quicksort#1#(@l)):5 -->_1 append#(@l,@ys) -> c_6(append#1#(@l,@ys)):1 8:S:quicksortD#(@l) -> c_16(quicksortD#1#(@l)) -->_1 quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)):9 -->_1 quicksortD#1#(nil()) -> c_18():40 9:S:quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) -->_2 splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)):13 -->_1 quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)):10 10:S:quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) -->_3 quicksortD#(@l) -> c_16(quicksortD#1#(@l)):8 -->_2 quicksortD#(@l) -> c_16(quicksortD#1#(@l)):8 -->_1 appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)):3 11:S:split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) -->_1 split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)):12 -->_1 split#1#(nil(),@pivot) -> c_22():41 12:S:split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) -->_1 split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)):42 -->_2 split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)):11 13:S:splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) -->_1 splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x) ,splitD#(@pivot,@xs)):14 -->_1 splitD#1#(nil(),@pivot) -> c_28():45 14:S:splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) -->_1 splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)):46 -->_2 splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)):13 15:S:testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) -->_2 testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))):49 -->_1 quicksort#(@l) -> c_12(quicksort#1#(@l)):5 16:S:testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) -->_2 testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))):49 -->_1 quicksort#(@l) -> c_12(quicksort#1#(@l)):5 17:W:#abs#(#0()) -> c_1() 18:W:#abs#(#neg(@x)) -> c_2() 19:W:#abs#(#pos(@x)) -> c_3() 20:W:#abs#(#s(@x)) -> c_4() 21:W:#ckgt#(#EQ()) -> c_35() 22:W:#ckgt#(#GT()) -> c_36() 23:W:#ckgt#(#LT()) -> c_37() 24:W:#compare#(#0(),#0()) -> c_38() 25:W:#compare#(#0(),#neg(@y)) -> c_39() 26:W:#compare#(#0(),#pos(@y)) -> c_40() 27:W:#compare#(#0(),#s(@y)) -> c_41() 28:W:#compare#(#neg(@x),#0()) -> c_42() 29:W:#compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)) -->_1 #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)):35 -->_1 #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)):33 -->_1 #compare#(#s(@x),#0()) -> c_48():34 -->_1 #compare#(#pos(@x),#neg(@y)) -> c_46():32 -->_1 #compare#(#pos(@x),#0()) -> c_45():31 -->_1 #compare#(#neg(@x),#pos(@y)) -> c_44():30 -->_1 #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)):29 -->_1 #compare#(#neg(@x),#0()) -> c_42():28 -->_1 #compare#(#0(),#s(@y)) -> c_41():27 -->_1 #compare#(#0(),#pos(@y)) -> c_40():26 -->_1 #compare#(#0(),#neg(@y)) -> c_39():25 -->_1 #compare#(#0(),#0()) -> c_38():24 30:W:#compare#(#neg(@x),#pos(@y)) -> c_44() 31:W:#compare#(#pos(@x),#0()) -> c_45() 32:W:#compare#(#pos(@x),#neg(@y)) -> c_46() 33:W:#compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)) -->_1 #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)):35 -->_1 #compare#(#s(@x),#0()) -> c_48():34 -->_1 #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)):33 -->_1 #compare#(#pos(@x),#neg(@y)) -> c_46():32 -->_1 #compare#(#pos(@x),#0()) -> c_45():31 -->_1 #compare#(#neg(@x),#pos(@y)) -> c_44():30 -->_1 #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)):29 -->_1 #compare#(#neg(@x),#0()) -> c_42():28 -->_1 #compare#(#0(),#s(@y)) -> c_41():27 -->_1 #compare#(#0(),#pos(@y)) -> c_40():26 -->_1 #compare#(#0(),#neg(@y)) -> c_39():25 -->_1 #compare#(#0(),#0()) -> c_38():24 34:W:#compare#(#s(@x),#0()) -> c_48() 35:W:#compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)) -->_1 #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)):35 -->_1 #compare#(#s(@x),#0()) -> c_48():34 -->_1 #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)):33 -->_1 #compare#(#pos(@x),#neg(@y)) -> c_46():32 -->_1 #compare#(#pos(@x),#0()) -> c_45():31 -->_1 #compare#(#neg(@x),#pos(@y)) -> c_44():30 -->_1 #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)):29 -->_1 #compare#(#neg(@x),#0()) -> c_42():28 -->_1 #compare#(#0(),#s(@y)) -> c_41():27 -->_1 #compare#(#0(),#pos(@y)) -> c_40():26 -->_1 #compare#(#0(),#neg(@y)) -> c_39():25 -->_1 #compare#(#0(),#0()) -> c_38():24 36:W:#greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)) -->_2 #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)):35 -->_2 #compare#(#s(@x),#0()) -> c_48():34 -->_2 #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)):33 -->_2 #compare#(#pos(@x),#neg(@y)) -> c_46():32 -->_2 #compare#(#pos(@x),#0()) -> c_45():31 -->_2 #compare#(#neg(@x),#pos(@y)) -> c_44():30 -->_2 #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)):29 -->_2 #compare#(#neg(@x),#0()) -> c_42():28 -->_2 #compare#(#0(),#s(@y)) -> c_41():27 -->_2 #compare#(#0(),#pos(@y)) -> c_40():26 -->_2 #compare#(#0(),#neg(@y)) -> c_39():25 -->_2 #compare#(#0(),#0()) -> c_38():24 -->_1 #ckgt#(#LT()) -> c_37():23 -->_1 #ckgt#(#GT()) -> c_36():22 -->_1 #ckgt#(#EQ()) -> c_35():21 37:W:append#1#(nil(),@ys) -> c_8() 38:W:appendD#1#(nil(),@ys) -> c_11() 39:W:quicksort#1#(nil()) -> c_14() 40:W:quicksortD#1#(nil()) -> c_18() 41:W:split#1#(nil(),@pivot) -> c_22() 42:W:split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) -->_1 split#3#(#true(),@ls,@rs,@x) -> c_25():44 -->_1 split#3#(#false(),@ls,@rs,@x) -> c_24():43 -->_2 #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)):36 43:W:split#3#(#false(),@ls,@rs,@x) -> c_24() 44:W:split#3#(#true(),@ls,@rs,@x) -> c_25() 45:W:splitD#1#(nil(),@pivot) -> c_28() 46:W:splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) -->_1 splitD#3#(#true(),@ls,@rs,@x) -> c_31():48 -->_1 splitD#3#(#false(),@ls,@rs,@x) -> c_30():47 -->_2 #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)):36 47:W:splitD#3#(#false(),@ls,@rs,@x) -> c_30() 48:W:splitD#3#(#true(),@ls,@rs,@x) -> c_31() 49:W:testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))) -->_10 #abs#(#pos(@x)) -> c_3():19 -->_9 #abs#(#pos(@x)) -> c_3():19 -->_8 #abs#(#pos(@x)) -> c_3():19 -->_7 #abs#(#pos(@x)) -> c_3():19 -->_6 #abs#(#pos(@x)) -> c_3():19 -->_5 #abs#(#pos(@x)) -> c_3():19 -->_4 #abs#(#pos(@x)) -> c_3():19 -->_3 #abs#(#pos(@x)) -> c_3():19 -->_2 #abs#(#pos(@x)) -> c_3():19 -->_1 #abs#(#0()) -> c_1():17 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 20: #abs#(#s(@x)) -> c_4() 18: #abs#(#neg(@x)) -> c_2() 49: testList#(@x) -> c_32(#abs#(#0()) ,#abs#(#pos(#s(#s(#s(#s(#0())))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#0()))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,#abs#(#pos(#s(#0()))) ,#abs#(#pos(#s(#s(#0())))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,#abs#(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,#abs#(#pos(#s(#s(#s(#0())))))) 17: #abs#(#0()) -> c_1() 19: #abs#(#pos(@x)) -> c_3() 40: quicksortD#1#(nil()) -> c_18() 45: splitD#1#(nil(),@pivot) -> c_28() 46: splitD#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_29(splitD#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) 47: splitD#3#(#false(),@ls,@rs,@x) -> c_30() 48: splitD#3#(#true(),@ls,@rs,@x) -> c_31() 39: quicksort#1#(nil()) -> c_14() 41: split#1#(nil(),@pivot) -> c_22() 42: split#2#(tuple#2(@ls,@rs),@pivot,@x) -> c_23(split#3#(#greater(@x,@pivot),@ls,@rs,@x) ,#greater#(@x,@pivot)) 36: #greater#(@x,@y) -> c_5(#ckgt#(#compare(@x,@y)),#compare#(@x,@y)) 21: #ckgt#(#EQ()) -> c_35() 22: #ckgt#(#GT()) -> c_36() 23: #ckgt#(#LT()) -> c_37() 35: #compare#(#s(@x),#s(@y)) -> c_49(#compare#(@x,@y)) 33: #compare#(#pos(@x),#pos(@y)) -> c_47(#compare#(@x,@y)) 29: #compare#(#neg(@x),#neg(@y)) -> c_43(#compare#(@y,@x)) 24: #compare#(#0(),#0()) -> c_38() 25: #compare#(#0(),#neg(@y)) -> c_39() 26: #compare#(#0(),#pos(@y)) -> c_40() 27: #compare#(#0(),#s(@y)) -> c_41() 28: #compare#(#neg(@x),#0()) -> c_42() 30: #compare#(#neg(@x),#pos(@y)) -> c_44() 31: #compare#(#pos(@x),#0()) -> c_45() 32: #compare#(#pos(@x),#neg(@y)) -> c_46() 34: #compare#(#s(@x),#0()) -> c_48() 43: split#3#(#false(),@ls,@rs,@x) -> c_24() 44: split#3#(#true(),@ls,@rs,@x) -> c_25() 38: appendD#1#(nil(),@ys) -> c_11() 37: append#1#(nil(),@ys) -> c_8() * Step 6: SimplifyRHS. WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) - Weak TRS: #abs(#0()) -> #0() #abs(#neg(@x)) -> #pos(@x) #abs(#pos(@x)) -> #pos(@x) #abs(#s(@x)) -> #pos(#s(@x)) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) testQuicksort(@x) -> quicksort(testList(#unit())) testQuicksort2(@x) -> quicksort(testList(#unit())) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/2 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/2,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/2,c_34/2,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:append#(@l,@ys) -> c_6(append#1#(@l,@ys)) -->_1 append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)):2 2:S:append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) -->_1 append#(@l,@ys) -> c_6(append#1#(@l,@ys)):1 3:S:appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) -->_1 appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)):4 4:S:appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) -->_1 appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)):3 5:S:quicksort#(@l) -> c_12(quicksort#1#(@l)) -->_1 quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)):6 6:S:quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) -->_2 split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)):11 -->_1 quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)):7 7:S:quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) -->_3 quicksort#(@l) -> c_12(quicksort#1#(@l)):5 -->_2 quicksort#(@l) -> c_12(quicksort#1#(@l)):5 -->_1 append#(@l,@ys) -> c_6(append#1#(@l,@ys)):1 8:S:quicksortD#(@l) -> c_16(quicksortD#1#(@l)) -->_1 quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)):9 9:S:quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) -->_2 splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)):13 -->_1 quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)):10 10:S:quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) -->_3 quicksortD#(@l) -> c_16(quicksortD#1#(@l)):8 -->_2 quicksortD#(@l) -> c_16(quicksortD#1#(@l)):8 -->_1 appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)):3 11:S:split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) -->_1 split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)):12 12:S:split#1#(::(@x,@xs),@pivot) -> c_21(split#2#(split(@pivot,@xs),@pivot,@x),split#(@pivot,@xs)) -->_2 split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)):11 13:S:splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) -->_1 splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x) ,splitD#(@pivot,@xs)):14 14:S:splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#2#(splitD(@pivot,@xs),@pivot,@x),splitD#(@pivot,@xs)) -->_2 splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)):13 15:S:testQuicksort#(@x) -> c_33(quicksort#(testList(#unit())),testList#(#unit())) -->_1 quicksort#(@l) -> c_12(quicksort#1#(@l)):5 16:S:testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit())),testList#(#unit())) -->_1 quicksort#(@l) -> c_12(quicksort#1#(@l)):5 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) * Step 7: UsableRules. WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#neg(@x)) -> #pos(@x) #abs(#pos(@x)) -> #pos(@x) #abs(#s(@x)) -> #pos(#s(@x)) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) testQuicksort(@x) -> quicksort(testList(#unit())) testQuicksort2(@x) -> quicksort(testList(#unit())) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: UsableRules + Details: We replace rewrite rules by usable rules: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) * Step 8: DecomposeDG. WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: DecomposeDG {onSelection = all below first cut in WDG, onUpper = Nothing, onLower = Nothing} + Details: We decompose the input problem according to the dependency graph into the upper component quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) and a lower component append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) Further, following extension rules are added to the lower component. quicksort#(@l) -> quicksort#1#(@l) quicksort#1#(::(@z,@zs)) -> quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) -> split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) -> append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@ys) quicksortD#(@l) -> quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) -> quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) -> splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@ys) testQuicksort#(@x) -> quicksort#(testList(#unit())) testQuicksort2#(@x) -> quicksort#(testList(#unit())) ** Step 8.a:1: SimplifyRHS. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:quicksort#(@l) -> c_12(quicksort#1#(@l)) -->_1 quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)):2 2:S:quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z),split#(@z,@zs)) -->_1 quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)):3 3:S:quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(append#(quicksort(@xs),::(@z,quicksort(@ys))) ,quicksort#(@xs) ,quicksort#(@ys)) -->_3 quicksort#(@l) -> c_12(quicksort#1#(@l)):1 -->_2 quicksort#(@l) -> c_12(quicksort#1#(@l)):1 4:S:quicksortD#(@l) -> c_16(quicksortD#1#(@l)) -->_1 quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)):5 5:S:quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z),splitD#(@z,@zs)) -->_1 quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)):6 6:S:quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) ,quicksortD#(@xs) ,quicksortD#(@ys)) -->_3 quicksortD#(@l) -> c_16(quicksortD#1#(@l)):4 -->_2 quicksortD#(@l) -> c_16(quicksortD#1#(@l)):4 7:S:testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) -->_1 quicksort#(@l) -> c_12(quicksort#1#(@l)):1 8:S:testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) -->_1 quicksort#(@l) -> c_12(quicksort#1#(@l)):1 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) ** Step 8.a:2: UsableRules. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/1,c_14/0,c_15/2,c_16/1,c_17/1,c_18/0,c_19/2,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: UsableRules + Details: We replace rewrite rules by usable rules: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) ** Step 8.a:3: NaturalMI. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/1,c_14/0,c_15/2,c_16/1,c_17/1,c_18/0,c_19/2,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_12) = {1}, uargs(c_13) = {1}, uargs(c_15) = {1,2}, uargs(c_16) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1,2}, uargs(c_33) = {1}, uargs(c_34) = {1} Following symbols are considered usable: {#abs#,#ckgt#,#compare#,#greater#,append#,append#1#,appendD#,appendD#1#,quicksort#,quicksort#1# ,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split#,split#1#,split#2#,split#3#,splitD#,splitD#1# ,splitD#2#,splitD#3#,testList#,testQuicksort#,testQuicksort2#} TcT has computed the following interpretation: p(#0) = [1] p(#EQ) = [1] p(#GT) = [0] p(#LT) = [0] p(#abs) = [5] p(#ckgt) = [1] x1 + [1] p(#compare) = [4] x1 + [1] x2 + [2] p(#false) = [0] p(#greater) = [4] x2 + [0] p(#neg) = [1] x1 + [0] p(#pos) = [0] p(#s) = [0] p(#true) = [0] p(#unit) = [2] p(::) = [1] x1 + [0] p(append) = [1] x1 + [1] p(append#1) = [1] x1 + [0] p(appendD) = [2] p(appendD#1) = [0] p(nil) = [1] p(quicksort) = [1] x1 + [0] p(quicksort#1) = [0] p(quicksort#2) = [0] p(quicksortD) = [0] p(quicksortD#1) = [4] p(quicksortD#2) = [4] x1 + [0] p(split) = [0] p(split#1) = [6] x1 + [0] p(split#2) = [2] p(split#3) = [4] x3 + [2] p(splitD) = [1] x1 + [0] p(splitD#1) = [1] x2 + [0] p(splitD#2) = [5] x1 + [5] x2 + [1] p(splitD#3) = [4] x2 + [2] x4 + [4] p(testList) = [0] p(testQuicksort) = [2] p(testQuicksort2) = [1] p(tuple#2) = [1] x2 + [1] p(#abs#) = [0] p(#ckgt#) = [1] x1 + [1] p(#compare#) = [4] x1 + [0] p(#greater#) = [1] x1 + [4] x2 + [0] p(append#) = [4] x1 + [1] x2 + [4] p(append#1#) = [1] x1 + [1] x2 + [1] p(appendD#) = [0] p(appendD#1#) = [1] x1 + [0] p(quicksort#) = [0] p(quicksort#1#) = [0] p(quicksort#2#) = [0] p(quicksortD#) = [0] p(quicksortD#1#) = [0] p(quicksortD#2#) = [0] p(split#) = [1] x1 + [4] p(split#1#) = [2] x2 + [0] p(split#2#) = [1] x1 + [1] x3 + [1] p(split#3#) = [4] x2 + [4] x4 + [0] p(splitD#) = [2] p(splitD#1#) = [2] x1 + [1] p(splitD#2#) = [1] x1 + [2] x2 + [1] p(splitD#3#) = [2] x3 + [2] p(testList#) = [2] x1 + [1] p(testQuicksort#) = [4] p(testQuicksort2#) = [4] x1 + [5] p(c_1) = [1] p(c_2) = [1] p(c_3) = [0] p(c_4) = [4] p(c_5) = [1] x1 + [4] x2 + [1] p(c_6) = [0] p(c_7) = [0] p(c_8) = [1] p(c_9) = [2] x1 + [1] p(c_10) = [4] p(c_11) = [1] p(c_12) = [2] x1 + [0] p(c_13) = [4] x1 + [0] p(c_14) = [4] p(c_15) = [1] x1 + [4] x2 + [0] p(c_16) = [2] x1 + [0] p(c_17) = [2] x1 + [0] p(c_18) = [0] p(c_19) = [4] x1 + [2] x2 + [0] p(c_20) = [0] p(c_21) = [1] x1 + [4] p(c_22) = [1] p(c_23) = [1] x1 + [4] p(c_24) = [0] p(c_25) = [2] p(c_26) = [1] x1 + [0] p(c_27) = [2] x1 + [0] p(c_28) = [2] p(c_29) = [1] x1 + [0] p(c_30) = [4] p(c_31) = [1] p(c_32) = [1] x4 + [1] x6 + [1] x7 + [4] x8 + [2] p(c_33) = [1] x1 + [4] p(c_34) = [1] x1 + [1] p(c_35) = [1] p(c_36) = [2] p(c_37) = [0] p(c_38) = [1] p(c_39) = [4] p(c_40) = [1] p(c_41) = [0] p(c_42) = [0] p(c_43) = [0] p(c_44) = [1] p(c_45) = [0] p(c_46) = [0] p(c_47) = [1] x1 + [1] p(c_48) = [4] p(c_49) = [0] Following rules are strictly oriented: testQuicksort2#(@x) = [4] @x + [5] > [1] = c_34(quicksort#(testList(#unit()))) Following rules are (at-least) weakly oriented: quicksort#(@l) = [0] >= [0] = c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) = [0] >= [0] = c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) = [0] >= [0] = c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) = [0] >= [0] = c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) = [0] >= [0] = c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) = [0] >= [0] = c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) = [4] >= [4] = c_33(quicksort#(testList(#unit()))) ** Step 8.a:4: NaturalMI. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) - Weak DPs: testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/1,c_14/0,c_15/2,c_16/1,c_17/1,c_18/0,c_19/2,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_12) = {1}, uargs(c_13) = {1}, uargs(c_15) = {1,2}, uargs(c_16) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1,2}, uargs(c_33) = {1}, uargs(c_34) = {1} Following symbols are considered usable: {#abs#,#ckgt#,#compare#,#greater#,append#,append#1#,appendD#,appendD#1#,quicksort#,quicksort#1# ,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split#,split#1#,split#2#,split#3#,splitD#,splitD#1# ,splitD#2#,splitD#3#,testList#,testQuicksort#,testQuicksort2#} TcT has computed the following interpretation: p(#0) = [3] p(#EQ) = [0] p(#GT) = [0] p(#LT) = [0] p(#abs) = [3] x1 + [0] p(#ckgt) = [1] x1 + [0] p(#compare) = [1] x2 + [5] p(#false) = [0] p(#greater) = [1] x1 + [0] p(#neg) = [1] x1 + [0] p(#pos) = [3] p(#s) = [1] p(#true) = [0] p(#unit) = [0] p(::) = [0] p(append) = [0] p(append#1) = [0] p(appendD) = [0] p(appendD#1) = [0] p(nil) = [0] p(quicksort) = [0] p(quicksort#1) = [0] p(quicksort#2) = [0] p(quicksortD) = [0] p(quicksortD#1) = [0] p(quicksortD#2) = [0] p(split) = [0] p(split#1) = [0] p(split#2) = [0] p(split#3) = [1] x1 + [1] x3 + [0] p(splitD) = [0] p(splitD#1) = [0] p(splitD#2) = [1] x2 + [0] p(splitD#3) = [0] p(testList) = [0] p(testQuicksort) = [0] p(testQuicksort2) = [0] p(tuple#2) = [0] p(#abs#) = [0] p(#ckgt#) = [0] p(#compare#) = [0] p(#greater#) = [0] p(append#) = [0] p(append#1#) = [0] p(appendD#) = [0] p(appendD#1#) = [0] p(quicksort#) = [0] p(quicksort#1#) = [0] p(quicksort#2#) = [0] p(quicksortD#) = [0] p(quicksortD#1#) = [0] p(quicksortD#2#) = [0] p(split#) = [1] x1 + [0] p(split#1#) = [1] x2 + [1] p(split#2#) = [1] x1 + [1] x2 + [0] p(split#3#) = [0] p(splitD#) = [1] x1 + [2] x2 + [2] p(splitD#1#) = [4] x1 + [1] p(splitD#2#) = [2] p(splitD#3#) = [1] x3 + [1] x4 + [2] p(testList#) = [2] x1 + [4] p(testQuicksort#) = [4] p(testQuicksort2#) = [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [1] p(c_4) = [1] p(c_5) = [2] x2 + [0] p(c_6) = [4] x1 + [1] p(c_7) = [2] x1 + [2] p(c_8) = [0] p(c_9) = [4] p(c_10) = [0] p(c_11) = [1] p(c_12) = [4] x1 + [0] p(c_13) = [4] x1 + [0] p(c_14) = [0] p(c_15) = [1] x1 + [2] x2 + [0] p(c_16) = [4] x1 + [0] p(c_17) = [4] x1 + [0] p(c_18) = [1] p(c_19) = [4] x1 + [4] x2 + [0] p(c_20) = [1] x1 + [0] p(c_21) = [1] x1 + [0] p(c_22) = [4] p(c_23) = [1] p(c_24) = [0] p(c_25) = [4] p(c_26) = [4] x1 + [0] p(c_27) = [4] p(c_28) = [0] p(c_29) = [1] x1 + [1] p(c_30) = [0] p(c_31) = [4] p(c_32) = [4] x3 + [2] x4 + [4] x6 + [1] x9 + [0] p(c_33) = [2] x1 + [0] p(c_34) = [4] x1 + [0] p(c_35) = [4] p(c_36) = [1] p(c_37) = [0] p(c_38) = [1] p(c_39) = [1] p(c_40) = [1] p(c_41) = [0] p(c_42) = [1] p(c_43) = [1] x1 + [0] p(c_44) = [0] p(c_45) = [1] p(c_46) = [0] p(c_47) = [1] x1 + [1] p(c_48) = [4] p(c_49) = [4] x1 + [4] Following rules are strictly oriented: testQuicksort#(@x) = [4] > [0] = c_33(quicksort#(testList(#unit()))) Following rules are (at-least) weakly oriented: quicksort#(@l) = [0] >= [0] = c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) = [0] >= [0] = c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) = [0] >= [0] = c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) = [0] >= [0] = c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) = [0] >= [0] = c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) = [0] >= [0] = c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort2#(@x) = [0] >= [0] = c_34(quicksort#(testList(#unit()))) ** Step 8.a:5: WeightGap. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) - Weak DPs: testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/1,c_14/0,c_15/2,c_16/1,c_17/1,c_18/0,c_19/2,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following constant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(#ckgt) = {1}, uargs(::) = {1,2}, uargs(split#2) = {1}, uargs(split#3) = {1}, uargs(splitD#2) = {1}, uargs(splitD#3) = {1}, uargs(quicksort#) = {1}, uargs(quicksort#2#) = {1}, uargs(quicksortD#2#) = {1}, uargs(c_12) = {1}, uargs(c_13) = {1}, uargs(c_15) = {1,2}, uargs(c_16) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1,2}, uargs(c_33) = {1}, uargs(c_34) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(#0) = [0] p(#EQ) = [0] p(#GT) = [0] p(#LT) = [0] p(#abs) = [0] p(#ckgt) = [1] x1 + [0] p(#compare) = [0] p(#false) = [0] p(#greater) = [0] p(#neg) = [0] p(#pos) = [0] p(#s) = [0] p(#true) = [0] p(#unit) = [2] p(::) = [1] x1 + [1] x2 + [0] p(append) = [1] x1 + [4] p(append#1) = [4] p(appendD) = [4] x1 + [1] x2 + [0] p(appendD#1) = [2] x1 + [1] x2 + [1] p(nil) = [0] p(quicksort) = [1] x1 + [1] p(quicksort#1) = [4] x1 + [0] p(quicksort#2) = [1] p(quicksortD) = [4] p(quicksortD#1) = [0] p(quicksortD#2) = [1] x2 + [1] p(split) = [1] x2 + [0] p(split#1) = [1] x1 + [0] p(split#2) = [1] x1 + [1] x3 + [0] p(split#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(splitD) = [1] x2 + [0] p(splitD#1) = [1] x1 + [0] p(splitD#2) = [1] x1 + [1] x3 + [0] p(splitD#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(testList) = [0] p(testQuicksort) = [1] p(testQuicksort2) = [4] x1 + [0] p(tuple#2) = [1] x1 + [1] x2 + [0] p(#abs#) = [1] x1 + [1] p(#ckgt#) = [1] p(#compare#) = [1] x2 + [1] p(#greater#) = [1] x1 + [4] p(append#) = [1] p(append#1#) = [2] x1 + [1] p(appendD#) = [2] p(appendD#1#) = [2] x2 + [0] p(quicksort#) = [1] x1 + [0] p(quicksort#1#) = [1] x1 + [5] p(quicksort#2#) = [1] x1 + [4] p(quicksortD#) = [1] x1 + [4] p(quicksortD#1#) = [1] x1 + [1] p(quicksortD#2#) = [1] x1 + [1] x2 + [4] p(split#) = [1] x2 + [1] p(split#1#) = [4] x1 + [4] x2 + [0] p(split#2#) = [4] x1 + [1] x2 + [0] p(split#3#) = [1] x1 + [1] x2 + [1] p(splitD#) = [1] x2 + [2] p(splitD#1#) = [1] x1 + [0] p(splitD#2#) = [1] x1 + [2] x3 + [1] p(splitD#3#) = [1] x1 + [1] x2 + [1] x4 + [1] p(testList#) = [1] x1 + [0] p(testQuicksort#) = [2] p(testQuicksort2#) = [1] x1 + [1] p(c_1) = [0] p(c_2) = [1] p(c_3) = [0] p(c_4) = [0] p(c_5) = [1] x2 + [2] p(c_6) = [4] p(c_7) = [1] p(c_8) = [0] p(c_9) = [1] x1 + [0] p(c_10) = [0] p(c_11) = [1] p(c_12) = [1] x1 + [6] p(c_13) = [1] x1 + [2] p(c_14) = [1] p(c_15) = [1] x1 + [1] x2 + [4] p(c_16) = [1] x1 + [2] p(c_17) = [1] x1 + [1] p(c_18) = [1] p(c_19) = [1] x1 + [1] x2 + [6] p(c_20) = [2] p(c_21) = [0] p(c_22) = [1] p(c_23) = [2] x1 + [1] x2 + [4] p(c_24) = [4] p(c_25) = [2] p(c_26) = [1] p(c_27) = [2] p(c_28) = [1] p(c_29) = [0] p(c_30) = [0] p(c_31) = [0] p(c_32) = [4] x1 + [1] x2 + [4] x3 + [1] x4 + [1] x5 + [2] x7 + [4] x8 + [1] x10 + [0] p(c_33) = [1] x1 + [2] p(c_34) = [1] x1 + [1] p(c_35) = [1] p(c_36) = [1] p(c_37) = [0] p(c_38) = [0] p(c_39) = [0] p(c_40) = [4] p(c_41) = [2] p(c_42) = [0] p(c_43) = [2] x1 + [0] p(c_44) = [1] p(c_45) = [0] p(c_46) = [1] p(c_47) = [4] x1 + [0] p(c_48) = [0] p(c_49) = [1] x1 + [1] Following rules are strictly oriented: quicksortD#(@l) = [1] @l + [4] > [1] @l + [3] = c_16(quicksortD#1#(@l)) Following rules are (at-least) weakly oriented: quicksort#(@l) = [1] @l + [0] >= [1] @l + [11] = c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) = [1] @z + [1] @zs + [5] >= [1] @zs + [6] = c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [4] >= [1] @xs + [1] @ys + [4] = c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#1#(::(@z,@zs)) = [1] @z + [1] @zs + [1] >= [1] @z + [1] @zs + [5] = c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [4] >= [1] @xs + [1] @ys + [14] = c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) = [2] >= [2] = c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) = [1] @x + [1] >= [1] = c_34(quicksort#(testList(#unit()))) #abs(#0()) = [0] >= [0] = #0() #abs(#pos(@x)) = [0] >= [0] = #pos(@x) #ckgt(#EQ()) = [0] >= [0] = #false() #ckgt(#GT()) = [0] >= [0] = #true() #ckgt(#LT()) = [0] >= [0] = #false() #compare(#0(),#0()) = [0] >= [0] = #EQ() #compare(#0(),#neg(@y)) = [0] >= [0] = #GT() #compare(#0(),#pos(@y)) = [0] >= [0] = #LT() #compare(#0(),#s(@y)) = [0] >= [0] = #LT() #compare(#neg(@x),#0()) = [0] >= [0] = #LT() #compare(#neg(@x),#neg(@y)) = [0] >= [0] = #compare(@y,@x) #compare(#neg(@x),#pos(@y)) = [0] >= [0] = #LT() #compare(#pos(@x),#0()) = [0] >= [0] = #GT() #compare(#pos(@x),#neg(@y)) = [0] >= [0] = #GT() #compare(#pos(@x),#pos(@y)) = [0] >= [0] = #compare(@x,@y) #compare(#s(@x),#0()) = [0] >= [0] = #GT() #compare(#s(@x),#s(@y)) = [0] >= [0] = #compare(@x,@y) #greater(@x,@y) = [0] >= [0] = #ckgt(#compare(@x,@y)) split(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [0] >= [1] @x + [1] @xs + [0] = split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [0] >= [1] @x + [1] @xs + [0] = splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(@ls,::(@x,@rs)) testList(@x) = [0] >= [0] = ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))),::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. ** Step 8.a:6: WeightGap. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) - Weak DPs: quicksortD#(@l) -> c_16(quicksortD#1#(@l)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/1,c_14/0,c_15/2,c_16/1,c_17/1,c_18/0,c_19/2,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following constant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(#ckgt) = {1}, uargs(::) = {1,2}, uargs(split#2) = {1}, uargs(split#3) = {1}, uargs(splitD#2) = {1}, uargs(splitD#3) = {1}, uargs(quicksort#) = {1}, uargs(quicksort#2#) = {1}, uargs(quicksortD#2#) = {1}, uargs(c_12) = {1}, uargs(c_13) = {1}, uargs(c_15) = {1,2}, uargs(c_16) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1,2}, uargs(c_33) = {1}, uargs(c_34) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(#0) = [0] p(#EQ) = [0] p(#GT) = [0] p(#LT) = [0] p(#abs) = [0] p(#ckgt) = [1] x1 + [0] p(#compare) = [0] p(#false) = [0] p(#greater) = [0] p(#neg) = [0] p(#pos) = [0] p(#s) = [2] p(#true) = [0] p(#unit) = [0] p(::) = [1] x1 + [1] x2 + [0] p(append) = [2] x1 + [2] p(append#1) = [1] x1 + [1] p(appendD) = [2] x1 + [4] x2 + [0] p(appendD#1) = [2] x1 + [2] x2 + [0] p(nil) = [0] p(quicksort) = [1] x1 + [0] p(quicksort#1) = [1] x1 + [1] p(quicksort#2) = [1] x1 + [4] x2 + [0] p(quicksortD) = [1] x1 + [1] p(quicksortD#1) = [2] p(quicksortD#2) = [4] x1 + [0] p(split) = [1] x2 + [6] p(split#1) = [1] x1 + [6] p(split#2) = [1] x1 + [1] x3 + [0] p(split#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(splitD) = [1] x2 + [0] p(splitD#1) = [1] x1 + [0] p(splitD#2) = [1] x1 + [1] x3 + [0] p(splitD#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(testList) = [0] p(testQuicksort) = [1] x1 + [0] p(testQuicksort2) = [1] x1 + [1] p(tuple#2) = [1] x1 + [1] x2 + [0] p(#abs#) = [2] x1 + [0] p(#ckgt#) = [2] p(#compare#) = [1] x1 + [1] x2 + [1] p(#greater#) = [4] x1 + [2] x2 + [1] p(append#) = [2] x1 + [1] x2 + [0] p(append#1#) = [1] x1 + [1] x2 + [1] p(appendD#) = [1] x1 + [1] p(appendD#1#) = [0] p(quicksort#) = [1] x1 + [2] p(quicksort#1#) = [1] x1 + [0] p(quicksort#2#) = [1] x1 + [4] p(quicksortD#) = [1] x1 + [1] p(quicksortD#1#) = [1] x1 + [0] p(quicksortD#2#) = [1] x1 + [1] x2 + [5] p(split#) = [4] x1 + [1] p(split#1#) = [2] p(split#2#) = [1] x2 + [4] x3 + [1] p(split#3#) = [1] x3 + [0] p(splitD#) = [1] x2 + [0] p(splitD#1#) = [1] x1 + [1] x2 + [0] p(splitD#2#) = [0] p(splitD#3#) = [1] x1 + [4] x2 + [2] x3 + [2] x4 + [0] p(testList#) = [1] x1 + [0] p(testQuicksort#) = [2] x1 + [2] p(testQuicksort2#) = [1] x1 + [2] p(c_1) = [0] p(c_2) = [4] p(c_3) = [0] p(c_4) = [1] p(c_5) = [2] x1 + [4] x2 + [4] p(c_6) = [4] p(c_7) = [1] p(c_8) = [2] p(c_9) = [1] x1 + [0] p(c_10) = [1] x1 + [1] p(c_11) = [1] p(c_12) = [1] x1 + [0] p(c_13) = [1] x1 + [0] p(c_14) = [1] p(c_15) = [1] x1 + [1] x2 + [6] p(c_16) = [1] x1 + [0] p(c_17) = [1] x1 + [0] p(c_18) = [0] p(c_19) = [1] x1 + [1] x2 + [1] p(c_20) = [4] p(c_21) = [1] x1 + [1] p(c_22) = [0] p(c_23) = [1] x2 + [0] p(c_24) = [0] p(c_25) = [1] p(c_26) = [1] p(c_27) = [1] p(c_28) = [1] p(c_29) = [1] x1 + [1] x2 + [0] p(c_30) = [1] p(c_31) = [4] p(c_32) = [2] x1 + [1] x3 + [1] x4 + [1] x6 + [1] x9 + [0] p(c_33) = [1] x1 + [0] p(c_34) = [1] x1 + [0] p(c_35) = [1] p(c_36) = [1] p(c_37) = [4] p(c_38) = [1] p(c_39) = [4] p(c_40) = [4] p(c_41) = [0] p(c_42) = [1] p(c_43) = [4] x1 + [0] p(c_44) = [1] p(c_45) = [1] p(c_46) = [0] p(c_47) = [0] p(c_48) = [0] p(c_49) = [1] x1 + [2] Following rules are strictly oriented: quicksort#(@l) = [1] @l + [2] > [1] @l + [0] = c_12(quicksort#1#(@l)) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [5] > [1] @xs + [1] @ys + [3] = c_19(quicksortD#(@xs),quicksortD#(@ys)) Following rules are (at-least) weakly oriented: quicksort#1#(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @zs + [10] = c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [4] >= [1] @xs + [1] @ys + [10] = c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) = [1] @l + [1] >= [1] @l + [0] = c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [5] = c_17(quicksortD#2#(splitD(@z,@zs),@z)) testQuicksort#(@x) = [2] @x + [2] >= [2] = c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) = [1] @x + [2] >= [2] = c_34(quicksort#(testList(#unit()))) #abs(#0()) = [0] >= [0] = #0() #abs(#pos(@x)) = [0] >= [0] = #pos(@x) #ckgt(#EQ()) = [0] >= [0] = #false() #ckgt(#GT()) = [0] >= [0] = #true() #ckgt(#LT()) = [0] >= [0] = #false() #compare(#0(),#0()) = [0] >= [0] = #EQ() #compare(#0(),#neg(@y)) = [0] >= [0] = #GT() #compare(#0(),#pos(@y)) = [0] >= [0] = #LT() #compare(#0(),#s(@y)) = [0] >= [0] = #LT() #compare(#neg(@x),#0()) = [0] >= [0] = #LT() #compare(#neg(@x),#neg(@y)) = [0] >= [0] = #compare(@y,@x) #compare(#neg(@x),#pos(@y)) = [0] >= [0] = #LT() #compare(#pos(@x),#0()) = [0] >= [0] = #GT() #compare(#pos(@x),#neg(@y)) = [0] >= [0] = #GT() #compare(#pos(@x),#pos(@y)) = [0] >= [0] = #compare(@x,@y) #compare(#s(@x),#0()) = [0] >= [0] = #GT() #compare(#s(@x),#s(@y)) = [0] >= [0] = #compare(@x,@y) #greater(@x,@y) = [0] >= [0] = #ckgt(#compare(@x,@y)) split(@pivot,@l) = [1] @l + [6] >= [1] @l + [6] = split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [6] >= [1] @x + [1] @xs + [6] = split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) = [6] >= [0] = tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [0] >= [1] @x + [1] @xs + [0] = splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(@ls,::(@x,@rs)) testList(@x) = [0] >= [0] = ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))),::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. ** Step 8.a:7: WeightGap. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) - Weak DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/1,c_14/0,c_15/2,c_16/1,c_17/1,c_18/0,c_19/2,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following constant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(#ckgt) = {1}, uargs(::) = {1,2}, uargs(split#2) = {1}, uargs(split#3) = {1}, uargs(splitD#2) = {1}, uargs(splitD#3) = {1}, uargs(quicksort#) = {1}, uargs(quicksort#2#) = {1}, uargs(quicksortD#2#) = {1}, uargs(c_12) = {1}, uargs(c_13) = {1}, uargs(c_15) = {1,2}, uargs(c_16) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1,2}, uargs(c_33) = {1}, uargs(c_34) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(#0) = [0] p(#EQ) = [4] p(#GT) = [4] p(#LT) = [4] p(#abs) = [0] p(#ckgt) = [1] x1 + [0] p(#compare) = [4] p(#false) = [4] p(#greater) = [4] p(#neg) = [4] p(#pos) = [0] p(#s) = [0] p(#true) = [4] p(#unit) = [0] p(::) = [1] x1 + [1] x2 + [0] p(append) = [4] x2 + [1] p(append#1) = [2] x1 + [1] p(appendD) = [1] x2 + [4] p(appendD#1) = [1] x2 + [4] p(nil) = [0] p(quicksort) = [4] p(quicksort#1) = [4] x1 + [0] p(quicksort#2) = [1] x2 + [1] p(quicksortD) = [2] x1 + [1] p(quicksortD#1) = [1] x1 + [1] p(quicksortD#2) = [1] x1 + [4] x2 + [1] p(split) = [1] x2 + [4] p(split#1) = [1] x1 + [4] p(split#2) = [1] x1 + [1] x3 + [0] p(split#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(splitD) = [1] x2 + [4] p(splitD#1) = [1] x1 + [4] p(splitD#2) = [1] x1 + [1] x3 + [0] p(splitD#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(testList) = [0] p(testQuicksort) = [1] p(testQuicksort2) = [2] p(tuple#2) = [1] x1 + [1] x2 + [4] p(#abs#) = [0] p(#ckgt#) = [1] x1 + [1] p(#compare#) = [4] x1 + [0] p(#greater#) = [1] x1 + [0] p(append#) = [1] p(append#1#) = [1] x1 + [1] x2 + [1] p(appendD#) = [1] x1 + [0] p(appendD#1#) = [0] p(quicksort#) = [1] x1 + [1] p(quicksort#1#) = [1] x1 + [0] p(quicksort#2#) = [1] x1 + [1] p(quicksortD#) = [1] x1 + [4] p(quicksortD#1#) = [1] x1 + [0] p(quicksortD#2#) = [1] x1 + [1] x2 + [5] p(split#) = [1] x1 + [2] x2 + [4] p(split#1#) = [1] p(split#2#) = [2] x1 + [1] x3 + [1] p(split#3#) = [1] x3 + [1] x4 + [0] p(splitD#) = [1] p(splitD#1#) = [1] x1 + [0] p(splitD#2#) = [0] p(splitD#3#) = [1] x1 + [1] x2 + [1] x3 + [2] x4 + [0] p(testList#) = [0] p(testQuicksort#) = [1] x1 + [1] p(testQuicksort2#) = [2] p(c_1) = [1] p(c_2) = [2] p(c_3) = [1] p(c_4) = [0] p(c_5) = [1] x1 + [2] x2 + [0] p(c_6) = [1] x1 + [1] p(c_7) = [2] x1 + [0] p(c_8) = [4] p(c_9) = [0] p(c_10) = [4] x1 + [0] p(c_11) = [2] p(c_12) = [1] x1 + [0] p(c_13) = [1] x1 + [1] p(c_14) = [1] p(c_15) = [1] x1 + [1] x2 + [2] p(c_16) = [1] x1 + [0] p(c_17) = [1] x1 + [3] p(c_18) = [0] p(c_19) = [1] x1 + [1] x2 + [1] p(c_20) = [1] x1 + [0] p(c_21) = [0] p(c_22) = [1] p(c_23) = [1] x2 + [1] p(c_24) = [1] p(c_25) = [4] p(c_26) = [4] p(c_27) = [1] x1 + [1] p(c_28) = [0] p(c_29) = [1] x1 + [4] x2 + [1] p(c_30) = [1] p(c_31) = [2] p(c_32) = [4] x1 + [1] x2 + [1] x3 + [1] x6 + [1] x9 + [1] x10 + [1] p(c_33) = [1] x1 + [0] p(c_34) = [1] x1 + [1] p(c_35) = [0] p(c_36) = [0] p(c_37) = [0] p(c_38) = [0] p(c_39) = [0] p(c_40) = [0] p(c_41) = [1] p(c_42) = [1] p(c_43) = [1] x1 + [1] p(c_44) = [1] p(c_45) = [1] p(c_46) = [0] p(c_47) = [0] p(c_48) = [4] p(c_49) = [1] x1 + [0] Following rules are strictly oriented: quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [5] > [1] @xs + [1] @ys + [4] = c_15(quicksort#(@xs),quicksort#(@ys)) Following rules are (at-least) weakly oriented: quicksort#(@l) = [1] @l + [1] >= [1] @l + [0] = c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @zs + [6] = c_13(quicksort#2#(split(@z,@zs),@z)) quicksortD#(@l) = [1] @l + [4] >= [1] @l + [0] = c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [12] = c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [9] >= [1] @xs + [1] @ys + [9] = c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) = [1] @x + [1] >= [1] = c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) = [2] >= [2] = c_34(quicksort#(testList(#unit()))) #abs(#0()) = [0] >= [0] = #0() #abs(#pos(@x)) = [0] >= [0] = #pos(@x) #ckgt(#EQ()) = [4] >= [4] = #false() #ckgt(#GT()) = [4] >= [4] = #true() #ckgt(#LT()) = [4] >= [4] = #false() #compare(#0(),#0()) = [4] >= [4] = #EQ() #compare(#0(),#neg(@y)) = [4] >= [4] = #GT() #compare(#0(),#pos(@y)) = [4] >= [4] = #LT() #compare(#0(),#s(@y)) = [4] >= [4] = #LT() #compare(#neg(@x),#0()) = [4] >= [4] = #LT() #compare(#neg(@x),#neg(@y)) = [4] >= [4] = #compare(@y,@x) #compare(#neg(@x),#pos(@y)) = [4] >= [4] = #LT() #compare(#pos(@x),#0()) = [4] >= [4] = #GT() #compare(#pos(@x),#neg(@y)) = [4] >= [4] = #GT() #compare(#pos(@x),#pos(@y)) = [4] >= [4] = #compare(@x,@y) #compare(#s(@x),#0()) = [4] >= [4] = #GT() #compare(#s(@x),#s(@y)) = [4] >= [4] = #compare(@x,@y) #greater(@x,@y) = [4] >= [4] = #ckgt(#compare(@x,@y)) split(@pivot,@l) = [1] @l + [4] >= [1] @l + [4] = split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [4] >= [1] @x + [1] @xs + [4] = split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) = [4] >= [4] = tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [4] >= [1] @ls + [1] @rs + [1] @x + [4] = split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [4] >= [1] @ls + [1] @rs + [1] @x + [4] = tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [4] >= [1] @ls + [1] @rs + [1] @x + [4] = tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) = [1] @l + [4] >= [1] @l + [4] = splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [4] >= [1] @x + [1] @xs + [4] = splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) = [4] >= [4] = tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [4] >= [1] @ls + [1] @rs + [1] @x + [4] = splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [4] >= [1] @ls + [1] @rs + [1] @x + [4] = tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [4] >= [1] @ls + [1] @rs + [1] @x + [4] = tuple#2(@ls,::(@x,@rs)) testList(@x) = [0] >= [0] = ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))),::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. ** Step 8.a:8: NaturalMI. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) - Weak DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/1,c_14/0,c_15/2,c_16/1,c_17/1,c_18/0,c_19/2,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_12) = {1}, uargs(c_13) = {1}, uargs(c_15) = {1,2}, uargs(c_16) = {1}, uargs(c_17) = {1}, uargs(c_19) = {1,2}, uargs(c_33) = {1}, uargs(c_34) = {1} Following symbols are considered usable: {splitD,splitD#1,splitD#2,splitD#3,#abs#,#ckgt#,#compare#,#greater#,append#,append#1#,appendD#,appendD#1# ,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split#,split#1#,split#2# ,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort#,testQuicksort2#} TcT has computed the following interpretation: p(#0) = [0] p(#EQ) = [0] p(#GT) = [4] p(#LT) = [2] p(#abs) = [0] p(#ckgt) = [2] x1 + [2] p(#compare) = [7] x1 + [6] p(#false) = [0] p(#greater) = [0] p(#neg) = [0] p(#pos) = [0] p(#s) = [0] p(#true) = [0] p(#unit) = [1] p(::) = [1] x2 + [1] p(append) = [4] x1 + [0] p(append#1) = [1] p(appendD) = [1] x2 + [4] p(appendD#1) = [1] x2 + [4] p(nil) = [0] p(quicksort) = [1] p(quicksort#1) = [1] x1 + [1] p(quicksort#2) = [2] x1 + [1] p(quicksortD) = [1] x1 + [1] p(quicksortD#1) = [0] p(quicksortD#2) = [1] x1 + [1] p(split) = [0] p(split#1) = [1] x2 + [0] p(split#2) = [0] p(split#3) = [4] x4 + [3] p(splitD) = [1] x2 + [0] p(splitD#1) = [1] x1 + [0] p(splitD#2) = [1] x1 + [1] p(splitD#3) = [1] x2 + [1] x3 + [1] p(testList) = [4] x1 + [3] p(testQuicksort) = [4] x1 + [0] p(testQuicksort2) = [0] p(tuple#2) = [1] x1 + [1] x2 + [0] p(#abs#) = [1] p(#ckgt#) = [4] x1 + [4] p(#compare#) = [1] x1 + [0] p(#greater#) = [1] p(append#) = [1] x1 + [1] x2 + [4] p(append#1#) = [2] p(appendD#) = [4] x2 + [1] p(appendD#1#) = [2] x1 + [1] p(quicksort#) = [0] p(quicksort#1#) = [0] p(quicksort#2#) = [0] p(quicksortD#) = [6] x1 + [0] p(quicksortD#1#) = [6] x1 + [0] p(quicksortD#2#) = [6] x1 + [0] p(split#) = [0] p(split#1#) = [1] x1 + [1] x2 + [4] p(split#2#) = [1] x3 + [0] p(split#3#) = [1] x3 + [1] x4 + [0] p(splitD#) = [1] x2 + [0] p(splitD#1#) = [2] x1 + [0] p(splitD#2#) = [1] x1 + [4] p(splitD#3#) = [1] x1 + [1] x2 + [1] x4 + [0] p(testList#) = [2] x1 + [1] p(testQuicksort#) = [5] p(testQuicksort2#) = [2] x1 + [5] p(c_1) = [4] p(c_2) = [0] p(c_3) = [1] p(c_4) = [1] p(c_5) = [4] x2 + [2] p(c_6) = [2] x1 + [0] p(c_7) = [2] x1 + [1] p(c_8) = [1] p(c_9) = [0] p(c_10) = [1] p(c_11) = [1] p(c_12) = [4] x1 + [0] p(c_13) = [1] x1 + [0] p(c_14) = [0] p(c_15) = [4] x1 + [4] x2 + [0] p(c_16) = [1] x1 + [0] p(c_17) = [1] x1 + [4] p(c_18) = [1] p(c_19) = [1] x1 + [1] x2 + [0] p(c_20) = [2] x1 + [1] p(c_21) = [1] x1 + [0] p(c_22) = [0] p(c_23) = [1] x1 + [4] x2 + [4] p(c_24) = [1] p(c_25) = [0] p(c_26) = [0] p(c_27) = [1] p(c_28) = [0] p(c_29) = [4] x1 + [4] x2 + [0] p(c_30) = [0] p(c_31) = [1] p(c_32) = [1] x2 + [1] x4 + [1] x10 + [1] p(c_33) = [1] x1 + [1] p(c_34) = [1] x1 + [5] p(c_35) = [1] p(c_36) = [0] p(c_37) = [2] p(c_38) = [1] p(c_39) = [0] p(c_40) = [1] p(c_41) = [1] p(c_42) = [1] p(c_43) = [1] x1 + [2] p(c_44) = [0] p(c_45) = [1] p(c_46) = [0] p(c_47) = [4] p(c_48) = [2] p(c_49) = [0] Following rules are strictly oriented: quicksortD#1#(::(@z,@zs)) = [6] @zs + [6] > [6] @zs + [4] = c_17(quicksortD#2#(splitD(@z,@zs),@z)) Following rules are (at-least) weakly oriented: quicksort#(@l) = [0] >= [0] = c_12(quicksort#1#(@l)) quicksort#1#(::(@z,@zs)) = [0] >= [0] = c_13(quicksort#2#(split(@z,@zs),@z)) quicksort#2#(tuple#2(@xs,@ys),@z) = [0] >= [0] = c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) = [6] @l + [0] >= [6] @l + [0] = c_16(quicksortD#1#(@l)) quicksortD#2#(tuple#2(@xs,@ys),@z) = [6] @xs + [6] @ys + [0] >= [6] @xs + [6] @ys + [0] = c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) = [5] >= [1] = c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) = [2] @x + [5] >= [5] = c_34(quicksort#(testList(#unit()))) splitD(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) = [1] @xs + [1] >= [1] @xs + [1] = splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = tuple#2(@ls,::(@x,@rs)) ** Step 8.a:9: Ara. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) - Weak DPs: quicksort#(@l) -> c_12(quicksort#1#(@l)) quicksort#2#(tuple#2(@xs,@ys),@z) -> c_15(quicksort#(@xs),quicksort#(@ys)) quicksortD#(@l) -> c_16(quicksortD#1#(@l)) quicksortD#1#(::(@z,@zs)) -> c_17(quicksortD#2#(splitD(@z,@zs),@z)) quicksortD#2#(tuple#2(@xs,@ys),@z) -> c_19(quicksortD#(@xs),quicksortD#(@ys)) testQuicksort#(@x) -> c_33(quicksort#(testList(#unit()))) testQuicksort2#(@x) -> c_34(quicksort#(testList(#unit()))) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/1,c_14/0,c_15/2,c_16/1,c_17/1,c_18/0,c_19/2,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: Ara {minDegree = 1, maxDegree = 2, araTimeout = 8, araRuleShifting = Just 1, isBestCase = False, mkCompletelyDefined = False, verboseOutput = False} + Details: Signatures used: ---------------- F (TrsFun "#0") :: [] -(0)-> "A"(1) F (TrsFun "#0") :: [] -(0)-> "A"(0) F (TrsFun "#0") :: [] -(0)-> "A"(14) F (TrsFun "#0") :: [] -(0)-> "A"(2) F (TrsFun "#0") :: [] -(0)-> "A"(12) F (TrsFun "#0") :: [] -(0)-> "A"(9) F (TrsFun "#EQ") :: [] -(0)-> "A"(1) F (TrsFun "#EQ") :: [] -(0)-> "A"(12) F (TrsFun "#GT") :: [] -(0)-> "A"(1) F (TrsFun "#GT") :: [] -(0)-> "A"(12) F (TrsFun "#LT") :: [] -(0)-> "A"(1) F (TrsFun "#LT") :: [] -(0)-> "A"(12) F (TrsFun "#abs") :: ["A"(1)] -(0)-> "A"(12) F (TrsFun "#ckgt") :: ["A"(1)] -(0)-> "A"(3) F (TrsFun "#compare") :: ["A"(0) x "A"(0)] -(0)-> "A"(2) F (TrsFun "#false") :: [] -(0)-> "A"(1) F (TrsFun "#false") :: [] -(0)-> "A"(0) F (TrsFun "#false") :: [] -(0)-> "A"(13) F (TrsFun "#false") :: [] -(0)-> "A"(14) F (TrsFun "#greater") :: ["A"(0) x "A"(0)] -(0)-> "A"(1) F (TrsFun "#neg") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(1) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(15) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(13) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(5) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(8) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(12) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(14) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(3) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(1) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(13) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(10) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(14) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(15) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(8) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(7) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(2) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(11) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(6) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(9) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(12) F (TrsFun "#true") :: [] -(0)-> "A"(1) F (TrsFun "#true") :: [] -(0)-> "A"(0) F (TrsFun "#true") :: [] -(0)-> "A"(14) F (TrsFun "#unit") :: [] -(0)-> "A"(12) F (TrsFun "::") :: ["A"(0) x "A"(1)] -(1)-> "A"(1) F (TrsFun "::") :: ["A"(0) x "A"(15)] -(15)-> "A"(15) F (TrsFun "nil") :: [] -(0)-> "A"(1) F (TrsFun "nil") :: [] -(0)-> "A"(15) F (TrsFun "nil") :: [] -(0)-> "A"(13) F (TrsFun "nil") :: [] -(0)-> "A"(5) F (TrsFun "split") :: ["A"(0) x "A"(1)] -(0)-> "A"(1) F (TrsFun "split#1") :: ["A"(1) x "A"(0)] -(0)-> "A"(1) F (TrsFun "split#2") :: ["A"(1) x "A"(0) x "A"(0)] -(1)-> "A"(1) F (TrsFun "split#3") :: ["A"(1) x "A"(1) x "A"(1) x "A"(0)] -(1)-> "A"(1) F (TrsFun "splitD") :: ["A"(0) x "A"(15)] -(0)-> "A"(15) F (TrsFun "splitD#1") :: ["A"(15) x "A"(0)] -(0)-> "A"(15) F (TrsFun "splitD#2") :: ["A"(15) x "A"(0) x "A"(0)] -(15)-> "A"(15) F (TrsFun "splitD#3") :: ["A"(0) x "A"(15) x "A"(15) x "A"(0)] -(15)-> "A"(15) F (TrsFun "testList") :: ["A"(5)] -(15)-> "A"(1) F (TrsFun "tuple#2") :: ["A"(1) x "A"(1)] -(0)-> "A"(1) F (TrsFun "tuple#2") :: ["A"(15) x "A"(15)] -(0)-> "A"(15) F (TrsFun "tuple#2") :: ["A"(9) x "A"(9)] -(0)-> "A"(9) F (DpFun "quicksort") :: ["A"(1)] -(0)-> "A"(4) F (DpFun "quicksort#1") :: ["A"(1)] -(0)-> "A"(14) F (DpFun "quicksort#2") :: ["A"(1) x "A"(0)] -(0)-> "A"(0) F (DpFun "quicksortD") :: ["A"(15)] -(7)-> "A"(1) F (DpFun "quicksortD#1") :: ["A"(15)] -(3)-> "A"(1) F (DpFun "quicksortD#2") :: ["A"(15) x "A"(0)] -(15)-> "A"(10) F (DpFun "testQuicksort") :: ["A"(0)] -(15)-> "A"(0) F (DpFun "testQuicksort2") :: ["A"(0)] -(15)-> "A"(0) F (ComFun 12) :: ["A"(7)] -(0)-> "A"(7) F (ComFun 13) :: ["A"(0)] -(0)-> "A"(15) F (ComFun 15) :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (ComFun 16) :: ["A"(1)] -(0)-> "A"(1) F (ComFun 17) :: ["A"(0)] -(3)-> "A"(3) F (ComFun 19) :: ["A"(0) x "A"(0)] -(0)-> "A"(14) F (ComFun 33) :: ["A"(4)] -(0)-> "A"(4) F (ComFun 34) :: ["A"(0)] -(0)-> "A"(0) Cost-free Signatures used: -------------------------- Base Constructor Signatures used: --------------------------------- "F (ComFun 12)_A" :: ["A"(1)] -(0)-> "A"(1) "F (ComFun 13)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 15)_A" :: ["A"(1) x "A"(1)] -(0)-> "A"(1) "F (ComFun 16)_A" :: ["A"(1)] -(0)-> "A"(1) "F (ComFun 17)_A" :: ["A"(0)] -(1)-> "A"(1) "F (ComFun 19)_A" :: ["A"(0) x "A"(0)] -(0)-> "A"(1) "F (ComFun 33)_A" :: ["A"(1)] -(0)-> "A"(1) "F (ComFun 34)_A" :: ["A"(1)] -(0)-> "A"(1) "F (TrsFun \"#0\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#EQ\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#GT\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#LT\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#false\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#neg\")_A" :: ["A"(1)] -(0)-> "A"(1) "F (TrsFun \"#pos\")_A" :: ["A"(0)] -(0)-> "A"(1) "F (TrsFun \"#s\")_A" :: ["A"(0)] -(0)-> "A"(1) "F (TrsFun \"#true\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#unit\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"::\")_A" :: ["A"(0) x "A"(1)] -(1)-> "A"(1) "F (TrsFun \"nil\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"tuple#2\")_A" :: ["A"(1) x "A"(1)] -(0)-> "A"(1) Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: quicksort#1#(::(@z,@zs)) -> c_13(quicksort#2#(split(@z,@zs),@z)) 2. Weak: ** Step 8.b:1: WeightGap. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) - Weak DPs: quicksort#(@l) -> quicksort#1#(@l) quicksort#1#(::(@z,@zs)) -> quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) -> split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) -> append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@ys) quicksortD#(@l) -> quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) -> quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) -> splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@ys) testQuicksort#(@x) -> quicksort#(testList(#unit())) testQuicksort2#(@x) -> quicksort#(testList(#unit())) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following constant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(#ckgt) = {1}, uargs(::) = {1,2}, uargs(append) = {1,2}, uargs(appendD) = {1,2}, uargs(quicksort#2) = {1}, uargs(quicksortD#2) = {1}, uargs(split#2) = {1}, uargs(split#3) = {1}, uargs(splitD#2) = {1}, uargs(splitD#3) = {1}, uargs(append#) = {1,2}, uargs(appendD#) = {1,2}, uargs(quicksort#) = {1}, uargs(quicksort#2#) = {1}, uargs(quicksortD#2#) = {1}, uargs(c_6) = {1}, uargs(c_7) = {1}, uargs(c_9) = {1}, uargs(c_10) = {1}, uargs(c_20) = {1}, uargs(c_21) = {1}, uargs(c_26) = {1}, uargs(c_27) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(#0) = [2] p(#EQ) = [0] p(#GT) = [0] p(#LT) = [0] p(#abs) = [1] x1 + [0] p(#ckgt) = [1] x1 + [0] p(#compare) = [0] p(#false) = [0] p(#greater) = [0] p(#neg) = [0] p(#pos) = [0] p(#s) = [4] p(#true) = [0] p(#unit) = [1] p(::) = [1] x1 + [1] x2 + [0] p(append) = [1] x1 + [1] x2 + [0] p(append#1) = [1] x1 + [1] x2 + [0] p(appendD) = [1] x1 + [1] x2 + [0] p(appendD#1) = [1] x1 + [1] x2 + [0] p(nil) = [0] p(quicksort) = [1] x1 + [0] p(quicksort#1) = [1] x1 + [0] p(quicksort#2) = [1] x1 + [1] x2 + [0] p(quicksortD) = [1] x1 + [0] p(quicksortD#1) = [1] x1 + [0] p(quicksortD#2) = [1] x1 + [1] x2 + [0] p(split) = [1] x2 + [0] p(split#1) = [1] x1 + [0] p(split#2) = [1] x1 + [1] x3 + [0] p(split#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(splitD) = [1] x2 + [0] p(splitD#1) = [1] x1 + [0] p(splitD#2) = [1] x1 + [1] x3 + [0] p(splitD#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(testList) = [2] p(testQuicksort) = [1] x1 + [0] p(testQuicksort2) = [2] x1 + [0] p(tuple#2) = [1] x1 + [1] x2 + [0] p(#abs#) = [4] x1 + [4] p(#ckgt#) = [0] p(#compare#) = [1] x1 + [2] p(#greater#) = [1] x2 + [1] p(append#) = [1] x1 + [1] x2 + [0] p(append#1#) = [1] x1 + [1] x2 + [4] p(appendD#) = [1] x1 + [1] x2 + [0] p(appendD#1#) = [1] x1 + [1] x2 + [5] p(quicksort#) = [1] x1 + [0] p(quicksort#1#) = [1] x1 + [0] p(quicksort#2#) = [1] x1 + [1] x2 + [0] p(quicksortD#) = [1] x1 + [1] p(quicksortD#1#) = [1] x1 + [1] p(quicksortD#2#) = [1] x1 + [1] x2 + [1] p(split#) = [1] x1 + [1] x2 + [0] p(split#1#) = [1] x1 + [1] x2 + [0] p(split#2#) = [1] x3 + [0] p(split#3#) = [4] x3 + [1] x4 + [4] p(splitD#) = [1] p(splitD#1#) = [0] p(splitD#2#) = [1] x1 + [1] x2 + [1] p(splitD#3#) = [1] x3 + [0] p(testList#) = [1] x1 + [0] p(testQuicksort#) = [2] x1 + [2] p(testQuicksort2#) = [1] x1 + [2] p(c_1) = [0] p(c_2) = [1] p(c_3) = [2] p(c_4) = [0] p(c_5) = [1] x2 + [0] p(c_6) = [1] x1 + [0] p(c_7) = [1] x1 + [2] p(c_8) = [4] p(c_9) = [1] x1 + [0] p(c_10) = [1] x1 + [1] p(c_11) = [2] p(c_12) = [4] x1 + [0] p(c_13) = [4] x1 + [1] p(c_14) = [0] p(c_15) = [1] x1 + [2] x2 + [1] x3 + [0] p(c_16) = [1] x1 + [2] p(c_17) = [2] p(c_18) = [1] p(c_19) = [4] x1 + [4] x2 + [4] x3 + [4] p(c_20) = [1] x1 + [1] p(c_21) = [1] x1 + [4] p(c_22) = [0] p(c_23) = [4] x2 + [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [1] x1 + [1] p(c_27) = [1] x1 + [4] p(c_28) = [0] p(c_29) = [2] x2 + [1] p(c_30) = [0] p(c_31) = [0] p(c_32) = [2] x2 + [1] x3 + [1] x5 + [1] x7 + [1] x9 + [0] p(c_33) = [0] p(c_34) = [0] p(c_35) = [1] p(c_36) = [2] p(c_37) = [1] p(c_38) = [1] p(c_39) = [0] p(c_40) = [2] p(c_41) = [1] p(c_42) = [0] p(c_43) = [1] x1 + [1] p(c_44) = [0] p(c_45) = [0] p(c_46) = [0] p(c_47) = [1] x1 + [4] p(c_48) = [0] p(c_49) = [1] x1 + [0] Following rules are strictly oriented: append#1#(::(@x,@xs),@ys) = [1] @x + [1] @xs + [1] @ys + [4] > [1] @xs + [1] @ys + [2] = c_7(append#(@xs,@ys)) appendD#1#(::(@x,@xs),@ys) = [1] @x + [1] @xs + [1] @ys + [5] > [1] @xs + [1] @ys + [1] = c_10(appendD#(@xs,@ys)) Following rules are (at-least) weakly oriented: append#(@l,@ys) = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [4] = c_6(append#1#(@l,@ys)) appendD#(@l,@ys) = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [5] = c_9(appendD#1#(@l,@ys)) quicksort#(@l) = [1] @l + [0] >= [1] @l + [0] = quicksort#1#(@l) quicksort#1#(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [0] = quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [0] = split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @xs + [1] @ys + [1] @z + [0] = append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @xs + [0] = quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @ys + [0] = quicksort#(@ys) quicksortD#(@l) = [1] @l + [1] >= [1] @l + [1] = quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) = [1] @z + [1] @zs + [1] >= [1] @z + [1] @zs + [1] = quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) = [1] @z + [1] @zs + [1] >= [1] = splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [1] >= [1] @xs + [1] @ys + [1] @z + [0] = appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [1] >= [1] @xs + [1] = quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [1] >= [1] @ys + [1] = quicksortD#(@ys) split#(@pivot,@l) = [1] @l + [1] @pivot + [0] >= [1] @l + [1] @pivot + [1] = c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) = [1] @pivot + [1] @x + [1] @xs + [0] >= [1] @pivot + [1] @xs + [4] = c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) = [1] >= [1] = c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) = [0] >= [5] = c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) = [2] @x + [2] >= [2] = quicksort#(testList(#unit())) testQuicksort2#(@x) = [1] @x + [2] >= [2] = quicksort#(testList(#unit())) #abs(#0()) = [2] >= [2] = #0() #abs(#pos(@x)) = [0] >= [0] = #pos(@x) #ckgt(#EQ()) = [0] >= [0] = #false() #ckgt(#GT()) = [0] >= [0] = #true() #ckgt(#LT()) = [0] >= [0] = #false() #compare(#0(),#0()) = [0] >= [0] = #EQ() #compare(#0(),#neg(@y)) = [0] >= [0] = #GT() #compare(#0(),#pos(@y)) = [0] >= [0] = #LT() #compare(#0(),#s(@y)) = [0] >= [0] = #LT() #compare(#neg(@x),#0()) = [0] >= [0] = #LT() #compare(#neg(@x),#neg(@y)) = [0] >= [0] = #compare(@y,@x) #compare(#neg(@x),#pos(@y)) = [0] >= [0] = #LT() #compare(#pos(@x),#0()) = [0] >= [0] = #GT() #compare(#pos(@x),#neg(@y)) = [0] >= [0] = #GT() #compare(#pos(@x),#pos(@y)) = [0] >= [0] = #compare(@x,@y) #compare(#s(@x),#0()) = [0] >= [0] = #GT() #compare(#s(@x),#s(@y)) = [0] >= [0] = #compare(@x,@y) #greater(@x,@y) = [0] >= [0] = #ckgt(#compare(@x,@y)) append(@l,@ys) = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = append#1(@l,@ys) append#1(::(@x,@xs),@ys) = [1] @x + [1] @xs + [1] @ys + [0] >= [1] @x + [1] @xs + [1] @ys + [0] = ::(@x,append(@xs,@ys)) append#1(nil(),@ys) = [1] @ys + [0] >= [1] @ys + [0] = @ys appendD(@l,@ys) = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) = [1] @x + [1] @xs + [1] @ys + [0] >= [1] @x + [1] @xs + [1] @ys + [0] = ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) = [1] @ys + [0] >= [1] @ys + [0] = @ys quicksort(@l) = [1] @l + [0] >= [1] @l + [0] = quicksort#1(@l) quicksort#1(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [0] = quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) = [0] >= [0] = nil() quicksort#2(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @xs + [1] @ys + [1] @z + [0] = append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) = [1] @l + [0] >= [1] @l + [0] = quicksortD#1(@l) quicksortD#1(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [0] = quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) = [0] >= [0] = nil() quicksortD#2(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @xs + [1] @ys + [1] @z + [0] = appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [0] >= [1] @x + [1] @xs + [0] = split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [0] >= [1] @x + [1] @xs + [0] = splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(@ls,::(@x,@rs)) testList(@x) = [2] >= [2] = ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))),::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. ** Step 8.b:2: WeightGap. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) - Weak DPs: append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> quicksort#1#(@l) quicksort#1#(::(@z,@zs)) -> quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) -> split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) -> append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@ys) quicksortD#(@l) -> quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) -> quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) -> splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@ys) testQuicksort#(@x) -> quicksort#(testList(#unit())) testQuicksort2#(@x) -> quicksort#(testList(#unit())) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following constant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(#ckgt) = {1}, uargs(::) = {1,2}, uargs(append) = {1,2}, uargs(appendD) = {1,2}, uargs(quicksort#2) = {1}, uargs(quicksortD#2) = {1}, uargs(split#2) = {1}, uargs(split#3) = {1}, uargs(splitD#2) = {1}, uargs(splitD#3) = {1}, uargs(append#) = {1,2}, uargs(appendD#) = {1,2}, uargs(quicksort#) = {1}, uargs(quicksort#2#) = {1}, uargs(quicksortD#2#) = {1}, uargs(c_6) = {1}, uargs(c_7) = {1}, uargs(c_9) = {1}, uargs(c_10) = {1}, uargs(c_20) = {1}, uargs(c_21) = {1}, uargs(c_26) = {1}, uargs(c_27) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(#0) = [0] p(#EQ) = [0] p(#GT) = [0] p(#LT) = [0] p(#abs) = [0] p(#ckgt) = [1] x1 + [0] p(#compare) = [0] p(#false) = [0] p(#greater) = [0] p(#neg) = [1] x1 + [2] p(#pos) = [0] p(#s) = [0] p(#true) = [0] p(#unit) = [5] p(::) = [1] x1 + [1] x2 + [0] p(append) = [1] x1 + [1] x2 + [0] p(append#1) = [1] x1 + [1] x2 + [0] p(appendD) = [1] x1 + [1] x2 + [0] p(appendD#1) = [1] x1 + [1] x2 + [0] p(nil) = [0] p(quicksort) = [1] x1 + [0] p(quicksort#1) = [1] x1 + [0] p(quicksort#2) = [1] x1 + [1] x2 + [0] p(quicksortD) = [1] x1 + [0] p(quicksortD#1) = [1] x1 + [0] p(quicksortD#2) = [1] x1 + [1] x2 + [0] p(split) = [1] x2 + [0] p(split#1) = [1] x1 + [0] p(split#2) = [1] x1 + [1] x3 + [0] p(split#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(splitD) = [1] x2 + [0] p(splitD#1) = [1] x1 + [0] p(splitD#2) = [1] x1 + [1] x3 + [0] p(splitD#3) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [0] p(testList) = [1] x1 + [2] p(testQuicksort) = [2] x1 + [0] p(testQuicksort2) = [4] x1 + [1] p(tuple#2) = [1] x1 + [1] x2 + [0] p(#abs#) = [1] x1 + [1] p(#ckgt#) = [2] x1 + [0] p(#compare#) = [1] p(#greater#) = [1] x1 + [4] x2 + [0] p(append#) = [1] x1 + [1] x2 + [0] p(append#1#) = [1] x1 + [1] x2 + [2] p(appendD#) = [1] x1 + [1] x2 + [1] p(appendD#1#) = [1] x1 + [1] x2 + [7] p(quicksort#) = [1] x1 + [0] p(quicksort#1#) = [1] x1 + [0] p(quicksort#2#) = [1] x1 + [1] x2 + [0] p(quicksortD#) = [1] x1 + [1] p(quicksortD#1#) = [1] x1 + [1] p(quicksortD#2#) = [1] x1 + [1] x2 + [1] p(split#) = [0] p(split#1#) = [7] p(split#2#) = [4] x1 + [1] x2 + [4] p(split#3#) = [4] x1 + [2] x2 + [2] x3 + [1] x4 + [0] p(splitD#) = [1] p(splitD#1#) = [7] p(splitD#2#) = [1] x3 + [2] p(splitD#3#) = [1] x1 + [4] x4 + [4] p(testList#) = [1] p(testQuicksort#) = [4] x1 + [7] p(testQuicksort2#) = [1] x1 + [7] p(c_1) = [1] p(c_2) = [1] p(c_3) = [1] p(c_4) = [4] p(c_5) = [0] p(c_6) = [1] x1 + [4] p(c_7) = [1] x1 + [2] p(c_8) = [1] p(c_9) = [1] x1 + [6] p(c_10) = [1] x1 + [5] p(c_11) = [0] p(c_12) = [4] p(c_13) = [0] p(c_14) = [1] p(c_15) = [1] x1 + [1] x3 + [1] p(c_16) = [1] x1 + [2] p(c_17) = [1] x1 + [2] x2 + [0] p(c_18) = [0] p(c_19) = [1] x1 + [1] x2 + [1] x3 + [1] p(c_20) = [1] x1 + [0] p(c_21) = [1] x1 + [4] p(c_22) = [0] p(c_23) = [2] x1 + [0] p(c_24) = [0] p(c_25) = [2] p(c_26) = [1] x1 + [2] p(c_27) = [1] x1 + [4] p(c_28) = [0] p(c_29) = [4] x1 + [1] x2 + [1] p(c_30) = [1] p(c_31) = [1] p(c_32) = [2] x4 + [1] x5 + [1] x6 + [1] x8 + [4] x10 + [1] p(c_33) = [2] x1 + [0] p(c_34) = [4] x1 + [0] p(c_35) = [0] p(c_36) = [1] p(c_37) = [4] p(c_38) = [1] p(c_39) = [0] p(c_40) = [0] p(c_41) = [1] p(c_42) = [1] p(c_43) = [4] x1 + [0] p(c_44) = [1] p(c_45) = [0] p(c_46) = [1] p(c_47) = [2] x1 + [0] p(c_48) = [0] p(c_49) = [1] x1 + [4] Following rules are strictly oriented: split#1#(::(@x,@xs),@pivot) = [7] > [4] = c_21(split#(@pivot,@xs)) splitD#1#(::(@x,@xs),@pivot) = [7] > [5] = c_27(splitD#(@pivot,@xs)) Following rules are (at-least) weakly oriented: append#(@l,@ys) = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [6] = c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) = [1] @x + [1] @xs + [1] @ys + [2] >= [1] @xs + [1] @ys + [2] = c_7(append#(@xs,@ys)) appendD#(@l,@ys) = [1] @l + [1] @ys + [1] >= [1] @l + [1] @ys + [13] = c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) = [1] @x + [1] @xs + [1] @ys + [7] >= [1] @xs + [1] @ys + [6] = c_10(appendD#(@xs,@ys)) quicksort#(@l) = [1] @l + [0] >= [1] @l + [0] = quicksort#1#(@l) quicksort#1#(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [0] = quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [0] = split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @xs + [1] @ys + [1] @z + [0] = append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @xs + [0] = quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @ys + [0] = quicksort#(@ys) quicksortD#(@l) = [1] @l + [1] >= [1] @l + [1] = quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) = [1] @z + [1] @zs + [1] >= [1] @z + [1] @zs + [1] = quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) = [1] @z + [1] @zs + [1] >= [1] = splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [1] >= [1] @xs + [1] @ys + [1] @z + [1] = appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [1] >= [1] @xs + [1] = quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [1] >= [1] @ys + [1] = quicksortD#(@ys) split#(@pivot,@l) = [0] >= [7] = c_20(split#1#(@l,@pivot)) splitD#(@pivot,@l) = [1] >= [9] = c_26(splitD#1#(@l,@pivot)) testQuicksort#(@x) = [4] @x + [7] >= [7] = quicksort#(testList(#unit())) testQuicksort2#(@x) = [1] @x + [7] >= [7] = quicksort#(testList(#unit())) #abs(#0()) = [0] >= [0] = #0() #abs(#pos(@x)) = [0] >= [0] = #pos(@x) #ckgt(#EQ()) = [0] >= [0] = #false() #ckgt(#GT()) = [0] >= [0] = #true() #ckgt(#LT()) = [0] >= [0] = #false() #compare(#0(),#0()) = [0] >= [0] = #EQ() #compare(#0(),#neg(@y)) = [0] >= [0] = #GT() #compare(#0(),#pos(@y)) = [0] >= [0] = #LT() #compare(#0(),#s(@y)) = [0] >= [0] = #LT() #compare(#neg(@x),#0()) = [0] >= [0] = #LT() #compare(#neg(@x),#neg(@y)) = [0] >= [0] = #compare(@y,@x) #compare(#neg(@x),#pos(@y)) = [0] >= [0] = #LT() #compare(#pos(@x),#0()) = [0] >= [0] = #GT() #compare(#pos(@x),#neg(@y)) = [0] >= [0] = #GT() #compare(#pos(@x),#pos(@y)) = [0] >= [0] = #compare(@x,@y) #compare(#s(@x),#0()) = [0] >= [0] = #GT() #compare(#s(@x),#s(@y)) = [0] >= [0] = #compare(@x,@y) #greater(@x,@y) = [0] >= [0] = #ckgt(#compare(@x,@y)) append(@l,@ys) = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = append#1(@l,@ys) append#1(::(@x,@xs),@ys) = [1] @x + [1] @xs + [1] @ys + [0] >= [1] @x + [1] @xs + [1] @ys + [0] = ::(@x,append(@xs,@ys)) append#1(nil(),@ys) = [1] @ys + [0] >= [1] @ys + [0] = @ys appendD(@l,@ys) = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) = [1] @x + [1] @xs + [1] @ys + [0] >= [1] @x + [1] @xs + [1] @ys + [0] = ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) = [1] @ys + [0] >= [1] @ys + [0] = @ys quicksort(@l) = [1] @l + [0] >= [1] @l + [0] = quicksort#1(@l) quicksort#1(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [0] = quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) = [0] >= [0] = nil() quicksort#2(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @xs + [1] @ys + [1] @z + [0] = append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) = [1] @l + [0] >= [1] @l + [0] = quicksortD#1(@l) quicksortD#1(::(@z,@zs)) = [1] @z + [1] @zs + [0] >= [1] @z + [1] @zs + [0] = quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) = [0] >= [0] = nil() quicksortD#2(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] @z + [0] >= [1] @xs + [1] @ys + [1] @z + [0] = appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [0] >= [1] @x + [1] @xs + [0] = split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) = [1] @x + [1] @xs + [0] >= [1] @x + [1] @xs + [0] = splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] @x + [0] >= [1] @ls + [1] @rs + [1] @x + [0] = tuple#2(@ls,::(@x,@rs)) testList(@x) = [1] @x + [2] >= [0] = ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))),::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. ** Step 8.b:3: NaturalMI. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) - Weak DPs: append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> quicksort#1#(@l) quicksort#1#(::(@z,@zs)) -> quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) -> split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) -> append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@ys) quicksortD#(@l) -> quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) -> quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) -> splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@ys) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) -> quicksort#(testList(#unit())) testQuicksort2#(@x) -> quicksort#(testList(#unit())) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_6) = {1}, uargs(c_7) = {1}, uargs(c_9) = {1}, uargs(c_10) = {1}, uargs(c_20) = {1}, uargs(c_21) = {1}, uargs(c_26) = {1}, uargs(c_27) = {1} Following symbols are considered usable: {splitD,splitD#1,splitD#2,splitD#3,#abs#,#ckgt#,#compare#,#greater#,append#,append#1#,appendD#,appendD#1# ,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split#,split#1#,split#2# ,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort#,testQuicksort2#} TcT has computed the following interpretation: p(#0) = [0] p(#EQ) = [0] p(#GT) = [0] p(#LT) = [1] p(#abs) = [2] p(#ckgt) = [4] x1 + [0] p(#compare) = [3] x1 + [3] x2 + [3] p(#false) = [0] p(#greater) = [0] p(#neg) = [1] p(#pos) = [0] p(#s) = [0] p(#true) = [0] p(#unit) = [3] p(::) = [1] x2 + [1] p(append) = [1] x1 + [1] p(append#1) = [4] p(appendD) = [7] x2 + [1] p(appendD#1) = [2] x1 + [3] p(nil) = [0] p(quicksort) = [0] p(quicksort#1) = [0] p(quicksort#2) = [6] x2 + [7] p(quicksortD) = [1] p(quicksortD#1) = [0] p(quicksortD#2) = [2] x1 + [2] x2 + [0] p(split) = [2] x1 + [0] p(split#1) = [1] x2 + [4] p(split#2) = [1] x2 + [0] p(split#3) = [2] x2 + [7] x4 + [5] p(splitD) = [1] x2 + [0] p(splitD#1) = [1] x1 + [0] p(splitD#2) = [1] x1 + [1] p(splitD#3) = [1] x2 + [1] x3 + [1] p(testList) = [3] x1 + [3] p(testQuicksort) = [1] p(testQuicksort2) = [1] p(tuple#2) = [1] x1 + [1] x2 + [0] p(#abs#) = [2] x1 + [4] p(#ckgt#) = [1] x1 + [1] p(#compare#) = [1] x2 + [0] p(#greater#) = [1] p(append#) = [0] p(append#1#) = [0] p(appendD#) = [0] p(appendD#1#) = [0] p(quicksort#) = [0] p(quicksort#1#) = [0] p(quicksort#2#) = [0] p(quicksortD#) = [4] x1 + [2] p(quicksortD#1#) = [4] x1 + [2] p(quicksortD#2#) = [4] x1 + [2] p(split#) = [0] p(split#1#) = [0] p(split#2#) = [2] x1 + [1] x2 + [1] p(split#3#) = [2] x2 + [2] x3 + [0] p(splitD#) = [4] x2 + [1] p(splitD#1#) = [4] x1 + [0] p(splitD#2#) = [4] x1 + [1] p(splitD#3#) = [4] x1 + [4] x4 + [0] p(testList#) = [4] x1 + [4] p(testQuicksort#) = [1] x1 + [2] p(testQuicksort2#) = [5] p(c_1) = [4] p(c_2) = [1] p(c_3) = [0] p(c_4) = [2] p(c_5) = [1] x2 + [0] p(c_6) = [4] x1 + [0] p(c_7) = [4] x1 + [0] p(c_8) = [0] p(c_9) = [4] x1 + [0] p(c_10) = [4] x1 + [0] p(c_11) = [2] p(c_12) = [1] x1 + [2] p(c_13) = [0] p(c_14) = [2] p(c_15) = [1] x1 + [4] x3 + [1] p(c_16) = [0] p(c_17) = [1] p(c_18) = [0] p(c_19) = [1] x1 + [1] x2 + [2] x3 + [0] p(c_20) = [1] x1 + [0] p(c_21) = [2] x1 + [0] p(c_22) = [2] p(c_23) = [1] x1 + [0] p(c_24) = [1] p(c_25) = [4] p(c_26) = [1] x1 + [0] p(c_27) = [1] x1 + [3] p(c_28) = [0] p(c_29) = [2] p(c_30) = [4] p(c_31) = [1] p(c_32) = [1] x1 + [4] x4 + [1] x6 + [2] x8 + [1] x9 + [2] x10 + [2] p(c_33) = [4] x1 + [2] p(c_34) = [0] p(c_35) = [0] p(c_36) = [1] p(c_37) = [4] p(c_38) = [1] p(c_39) = [0] p(c_40) = [0] p(c_41) = [0] p(c_42) = [2] p(c_43) = [2] x1 + [2] p(c_44) = [0] p(c_45) = [0] p(c_46) = [0] p(c_47) = [0] p(c_48) = [0] p(c_49) = [2] x1 + [4] Following rules are strictly oriented: splitD#(@pivot,@l) = [4] @l + [1] > [4] @l + [0] = c_26(splitD#1#(@l,@pivot)) Following rules are (at-least) weakly oriented: append#(@l,@ys) = [0] >= [0] = c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) = [0] >= [0] = c_7(append#(@xs,@ys)) appendD#(@l,@ys) = [0] >= [0] = c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) = [0] >= [0] = c_10(appendD#(@xs,@ys)) quicksort#(@l) = [0] >= [0] = quicksort#1#(@l) quicksort#1#(::(@z,@zs)) = [0] >= [0] = quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) = [0] >= [0] = split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) = [0] >= [0] = append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) = [0] >= [0] = quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) = [0] >= [0] = quicksort#(@ys) quicksortD#(@l) = [4] @l + [2] >= [4] @l + [2] = quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) = [4] @zs + [6] >= [4] @zs + [2] = quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) = [4] @zs + [6] >= [4] @zs + [1] = splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) = [4] @xs + [4] @ys + [2] >= [0] = appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) = [4] @xs + [4] @ys + [2] >= [4] @xs + [2] = quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) = [4] @xs + [4] @ys + [2] >= [4] @ys + [2] = quicksortD#(@ys) split#(@pivot,@l) = [0] >= [0] = c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) = [0] >= [0] = c_21(split#(@pivot,@xs)) splitD#1#(::(@x,@xs),@pivot) = [4] @xs + [4] >= [4] @xs + [4] = c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) = [1] @x + [2] >= [0] = quicksort#(testList(#unit())) testQuicksort2#(@x) = [5] >= [0] = quicksort#(testList(#unit())) splitD(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) = [1] @xs + [1] >= [1] @xs + [1] = splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = tuple#2(@ls,::(@x,@rs)) ** Step 8.b:4: NaturalMI. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) - Weak DPs: append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> quicksort#1#(@l) quicksort#1#(::(@z,@zs)) -> quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) -> split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) -> append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@ys) quicksortD#(@l) -> quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) -> quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) -> splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@ys) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) -> quicksort#(testList(#unit())) testQuicksort2#(@x) -> quicksort#(testList(#unit())) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_6) = {1}, uargs(c_7) = {1}, uargs(c_9) = {1}, uargs(c_10) = {1}, uargs(c_20) = {1}, uargs(c_21) = {1}, uargs(c_26) = {1}, uargs(c_27) = {1} Following symbols are considered usable: {appendD,appendD#1,quicksortD,quicksortD#1,quicksortD#2,splitD,splitD#1,splitD#2,splitD#3,#abs#,#ckgt# ,#compare#,#greater#,append#,append#1#,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD# ,quicksortD#1#,quicksortD#2#,split#,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3# ,testList#,testQuicksort#,testQuicksort2#} TcT has computed the following interpretation: p(#0) = [4] p(#EQ) = [1] p(#GT) = [0] p(#LT) = [0] p(#abs) = [2] x1 + [0] p(#ckgt) = [3] p(#compare) = [0] p(#false) = [0] p(#greater) = [0] p(#neg) = [0] p(#pos) = [4] p(#s) = [0] p(#true) = [0] p(#unit) = [5] p(::) = [1] x2 + [1] p(append) = [4] x2 + [2] p(append#1) = [0] p(appendD) = [1] x1 + [1] x2 + [0] p(appendD#1) = [1] x1 + [1] x2 + [0] p(nil) = [0] p(quicksort) = [2] p(quicksort#1) = [1] x1 + [0] p(quicksort#2) = [0] p(quicksortD) = [1] x1 + [0] p(quicksortD#1) = [1] x1 + [0] p(quicksortD#2) = [1] x1 + [1] p(split) = [0] p(split#1) = [0] p(split#2) = [1] p(split#3) = [2] x4 + [1] p(splitD) = [1] x2 + [0] p(splitD#1) = [1] x1 + [0] p(splitD#2) = [1] x1 + [1] p(splitD#3) = [1] x2 + [1] x3 + [1] p(testList) = [1] x1 + [0] p(testQuicksort) = [1] x1 + [0] p(testQuicksort2) = [1] p(tuple#2) = [1] x1 + [1] x2 + [0] p(#abs#) = [4] x1 + [1] p(#ckgt#) = [1] p(#compare#) = [2] x2 + [0] p(#greater#) = [4] x2 + [1] p(append#) = [1] p(append#1#) = [1] p(appendD#) = [4] x1 + [1] x2 + [1] p(appendD#1#) = [4] x1 + [1] x2 + [0] p(quicksort#) = [1] p(quicksort#1#) = [1] p(quicksort#2#) = [1] p(quicksortD#) = [4] x1 + [4] p(quicksortD#1#) = [4] x1 + [2] p(quicksortD#2#) = [4] x1 + [4] p(split#) = [0] p(split#1#) = [0] p(split#2#) = [4] x1 + [2] x2 + [1] p(split#3#) = [2] x2 + [1] x3 + [0] p(splitD#) = [0] p(splitD#1#) = [0] p(splitD#2#) = [0] p(splitD#3#) = [4] x3 + [1] p(testList#) = [1] p(testQuicksort#) = [2] p(testQuicksort2#) = [1] p(c_1) = [0] p(c_2) = [1] p(c_3) = [4] p(c_4) = [0] p(c_5) = [4] x1 + [1] p(c_6) = [1] x1 + [0] p(c_7) = [1] x1 + [0] p(c_8) = [1] p(c_9) = [1] x1 + [0] p(c_10) = [1] x1 + [1] p(c_11) = [1] p(c_12) = [0] p(c_13) = [1] p(c_14) = [1] p(c_15) = [1] x2 + [0] p(c_16) = [0] p(c_17) = [1] p(c_18) = [2] p(c_19) = [1] x2 + [0] p(c_20) = [2] x1 + [0] p(c_21) = [4] x1 + [0] p(c_22) = [1] p(c_23) = [1] x1 + [4] x2 + [0] p(c_24) = [0] p(c_25) = [1] p(c_26) = [4] x1 + [0] p(c_27) = [2] x1 + [0] p(c_28) = [0] p(c_29) = [1] x1 + [1] x2 + [1] p(c_30) = [1] p(c_31) = [1] p(c_32) = [1] x1 + [1] x2 + [1] x5 + [2] x6 + [1] x7 + [1] x9 + [0] p(c_33) = [1] p(c_34) = [1] x1 + [4] p(c_35) = [0] p(c_36) = [2] p(c_37) = [1] p(c_38) = [1] p(c_39) = [2] p(c_40) = [0] p(c_41) = [0] p(c_42) = [1] p(c_43) = [1] p(c_44) = [0] p(c_45) = [1] p(c_46) = [1] p(c_47) = [1] x1 + [0] p(c_48) = [4] p(c_49) = [1] x1 + [0] Following rules are strictly oriented: appendD#(@l,@ys) = [4] @l + [1] @ys + [1] > [4] @l + [1] @ys + [0] = c_9(appendD#1#(@l,@ys)) Following rules are (at-least) weakly oriented: append#(@l,@ys) = [1] >= [1] = c_6(append#1#(@l,@ys)) append#1#(::(@x,@xs),@ys) = [1] >= [1] = c_7(append#(@xs,@ys)) appendD#1#(::(@x,@xs),@ys) = [4] @xs + [1] @ys + [4] >= [4] @xs + [1] @ys + [2] = c_10(appendD#(@xs,@ys)) quicksort#(@l) = [1] >= [1] = quicksort#1#(@l) quicksort#1#(::(@z,@zs)) = [1] >= [1] = quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) = [1] >= [0] = split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] >= [1] = append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] >= [1] = quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) = [1] >= [1] = quicksort#(@ys) quicksortD#(@l) = [4] @l + [4] >= [4] @l + [2] = quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) = [4] @zs + [6] >= [4] @zs + [4] = quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) = [4] @zs + [6] >= [0] = splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) = [4] @xs + [4] @ys + [4] >= [4] @xs + [1] @ys + [2] = appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) = [4] @xs + [4] @ys + [4] >= [4] @xs + [4] = quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) = [4] @xs + [4] @ys + [4] >= [4] @ys + [4] = quicksortD#(@ys) split#(@pivot,@l) = [0] >= [0] = c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) = [0] >= [0] = c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) = [0] >= [0] = c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) = [0] >= [0] = c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) = [2] >= [1] = quicksort#(testList(#unit())) testQuicksort2#(@x) = [1] >= [1] = quicksort#(testList(#unit())) appendD(@l,@ys) = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) = [1] @xs + [1] @ys + [1] >= [1] @xs + [1] @ys + [1] = ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) = [1] @ys + [0] >= [1] @ys + [0] = @ys quicksortD(@l) = [1] @l + [0] >= [1] @l + [0] = quicksortD#1(@l) quicksortD#1(::(@z,@zs)) = [1] @zs + [1] >= [1] @zs + [1] = quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) = [0] >= [0] = nil() quicksortD#2(tuple#2(@xs,@ys),@z) = [1] @xs + [1] @ys + [1] >= [1] @xs + [1] @ys + [1] = appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) splitD(@pivot,@l) = [1] @l + [0] >= [1] @l + [0] = splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) = [1] @xs + [1] >= [1] @xs + [1] = splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) = [0] >= [0] = tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) = [1] @ls + [1] @rs + [1] >= [1] @ls + [1] @rs + [1] = tuple#2(@ls,::(@x,@rs)) ** Step 8.b:5: Ara. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) - Weak DPs: append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> quicksort#1#(@l) quicksort#1#(::(@z,@zs)) -> quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) -> split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) -> append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@ys) quicksortD#(@l) -> quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) -> quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) -> splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@ys) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) -> quicksort#(testList(#unit())) testQuicksort2#(@x) -> quicksort#(testList(#unit())) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: Ara {minDegree = 1, maxDegree = 2, araTimeout = 8, araRuleShifting = Just 1, isBestCase = False, mkCompletelyDefined = False, verboseOutput = False} + Details: Signatures used: ---------------- F (TrsFun "#0") :: [] -(0)-> "A"(1) F (TrsFun "#0") :: [] -(0)-> "A"(0) F (TrsFun "#0") :: [] -(0)-> "A"(14) F (TrsFun "#0") :: [] -(0)-> "A"(9) F (TrsFun "#0") :: [] -(0)-> "A"(8) F (TrsFun "#0") :: [] -(0)-> "A"(12) F (TrsFun "#0") :: [] -(0)-> "A"(10) F (TrsFun "#EQ") :: [] -(0)-> "A"(0) F (TrsFun "#GT") :: [] -(0)-> "A"(0) F (TrsFun "#LT") :: [] -(0)-> "A"(0) F (TrsFun "#abs") :: ["A"(1)] -(0)-> "A"(6) F (TrsFun "#ckgt") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#compare") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "#false") :: [] -(0)-> "A"(0) F (TrsFun "#greater") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "#neg") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(1) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(7) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(14) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(13) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(9) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(15) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(13) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(1) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(12) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(15) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(7) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(14) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(8) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(6) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(9) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(11) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(10) F (TrsFun "#true") :: [] -(0)-> "A"(0) F (TrsFun "#unit") :: [] -(0)-> "A"(0) F (TrsFun "::") :: ["A"(0) x "A"(1)] -(1)-> "A"(1) F (TrsFun "::") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "::") :: ["A"(0) x "A"(5)] -(5)-> "A"(5) F (TrsFun "::") :: ["A"(0) x "A"(2)] -(2)-> "A"(2) F (TrsFun "append") :: ["A"(1) x "A"(1)] -(0)-> "A"(1) F (TrsFun "append#1") :: ["A"(1) x "A"(1)] -(0)-> "A"(1) F (TrsFun "appendD") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "appendD#1") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "nil") :: [] -(0)-> "A"(1) F (TrsFun "nil") :: [] -(0)-> "A"(0) F (TrsFun "nil") :: [] -(0)-> "A"(5) F (TrsFun "nil") :: [] -(0)-> "A"(7) F (TrsFun "nil") :: [] -(0)-> "A"(8) F (TrsFun "nil") :: [] -(0)-> "A"(15) F (TrsFun "nil") :: [] -(0)-> "A"(14) F (TrsFun "quicksort") :: ["A"(1)] -(0)-> "A"(1) F (TrsFun "quicksort#1") :: ["A"(1)] -(0)-> "A"(1) F (TrsFun "quicksort#2") :: ["A"(1) x "A"(0)] -(1)-> "A"(1) F (TrsFun "quicksortD") :: ["A"(5)] -(0)-> "A"(0) F (TrsFun "quicksortD#1") :: ["A"(5)] -(0)-> "A"(0) F (TrsFun "quicksortD#2") :: ["A"(5) x "A"(0)] -(5)-> "A"(0) F (TrsFun "split") :: ["A"(0) x "A"(1)] -(0)-> "A"(1) F (TrsFun "split#1") :: ["A"(1) x "A"(0)] -(0)-> "A"(1) F (TrsFun "split#2") :: ["A"(1) x "A"(0) x "A"(0)] -(1)-> "A"(1) F (TrsFun "split#3") :: ["A"(0) x "A"(1) x "A"(1) x "A"(0)] -(1)-> "A"(1) F (TrsFun "splitD") :: ["A"(0) x "A"(5)] -(0)-> "A"(5) F (TrsFun "splitD#1") :: ["A"(5) x "A"(0)] -(0)-> "A"(5) F (TrsFun "splitD#2") :: ["A"(5) x "A"(0) x "A"(0)] -(5)-> "A"(5) F (TrsFun "splitD#3") :: ["A"(0) x "A"(5) x "A"(5) x "A"(0)] -(5)-> "A"(5) F (TrsFun "testList") :: ["A"(0)] -(15)-> "A"(1) F (TrsFun "tuple#2") :: ["A"(1) x "A"(1)] -(0)-> "A"(1) F (TrsFun "tuple#2") :: ["A"(5) x "A"(5)] -(0)-> "A"(5) F (TrsFun "tuple#2") :: ["A"(15) x "A"(15)] -(0)-> "A"(15) F (DpFun "append") :: ["A"(1) x "A"(0)] -(0)-> "A"(10) F (DpFun "append#1") :: ["A"(1) x "A"(0)] -(0)-> "A"(2) F (DpFun "appendD") :: ["A"(0) x "A"(0)] -(14)-> "A"(2) F (DpFun "appendD#1") :: ["A"(0) x "A"(0)] -(14)-> "A"(6) F (DpFun "quicksort") :: ["A"(1)] -(0)-> "A"(0) F (DpFun "quicksort#1") :: ["A"(1)] -(0)-> "A"(0) F (DpFun "quicksort#2") :: ["A"(1) x "A"(0)] -(1)-> "A"(0) F (DpFun "quicksortD") :: ["A"(5)] -(15)-> "A"(2) F (DpFun "quicksortD#1") :: ["A"(5)] -(14)-> "A"(2) F (DpFun "quicksortD#2") :: ["A"(5) x "A"(0)] -(15)-> "A"(2) F (DpFun "split") :: ["A"(0) x "A"(1)] -(1)-> "A"(14) F (DpFun "split#1") :: ["A"(1) x "A"(0)] -(0)-> "A"(12) F (DpFun "splitD") :: ["A"(0) x "A"(2)] -(2)-> "A"(7) F (DpFun "splitD#1") :: ["A"(2) x "A"(0)] -(0)-> "A"(15) F (DpFun "testQuicksort") :: ["A"(0)] -(15)-> "A"(0) F (DpFun "testQuicksort2") :: ["A"(0)] -(15)-> "A"(0) F (ComFun 6) :: ["A"(0)] -(0)-> "A"(11) F (ComFun 7) :: ["A"(0)] -(0)-> "A"(8) F (ComFun 9) :: ["A"(0)] -(0)-> "A"(6) F (ComFun 10) :: ["A"(0)] -(0)-> "A"(15) F (ComFun 20) :: ["A"(0)] -(0)-> "A"(15) F (ComFun 21) :: ["A"(0)] -(0)-> "A"(14) F (ComFun 26) :: ["A"(0)] -(0)-> "A"(7) F (ComFun 27) :: ["A"(0)] -(0)-> "A"(15) Cost-free Signatures used: -------------------------- Base Constructor Signatures used: --------------------------------- "F (ComFun 10)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 20)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 21)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 26)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 27)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 6)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 7)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 9)_A" :: ["A"(0)] -(0)-> "A"(1) "F (TrsFun \"#0\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#EQ\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#GT\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#LT\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#false\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#neg\")_A" :: ["A"(1)] -(1)-> "A"(1) "F (TrsFun \"#pos\")_A" :: ["A"(0)] -(0)-> "A"(1) "F (TrsFun \"#s\")_A" :: ["A"(0)] -(0)-> "A"(1) "F (TrsFun \"#true\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#unit\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"::\")_A" :: ["A"(0) x "A"(1)] -(1)-> "A"(1) "F (TrsFun \"nil\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"tuple#2\")_A" :: ["A"(1) x "A"(1)] -(0)-> "A"(1) Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) 2. Weak: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) ** Step 8.b:6: Ara. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) - Weak DPs: append#1#(::(@x,@xs),@ys) -> c_7(append#(@xs,@ys)) appendD#(@l,@ys) -> c_9(appendD#1#(@l,@ys)) appendD#1#(::(@x,@xs),@ys) -> c_10(appendD#(@xs,@ys)) quicksort#(@l) -> quicksort#1#(@l) quicksort#1#(::(@z,@zs)) -> quicksort#2#(split(@z,@zs),@z) quicksort#1#(::(@z,@zs)) -> split#(@z,@zs) quicksort#2#(tuple#2(@xs,@ys),@z) -> append#(quicksort(@xs),::(@z,quicksort(@ys))) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@xs) quicksort#2#(tuple#2(@xs,@ys),@z) -> quicksort#(@ys) quicksortD#(@l) -> quicksortD#1#(@l) quicksortD#1#(::(@z,@zs)) -> quicksortD#2#(splitD(@z,@zs),@z) quicksortD#1#(::(@z,@zs)) -> splitD#(@z,@zs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> appendD#(quicksortD(@xs),::(@z,quicksortD(@ys))) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@xs) quicksortD#2#(tuple#2(@xs,@ys),@z) -> quicksortD#(@ys) split#(@pivot,@l) -> c_20(split#1#(@l,@pivot)) split#1#(::(@x,@xs),@pivot) -> c_21(split#(@pivot,@xs)) splitD#(@pivot,@l) -> c_26(splitD#1#(@l,@pivot)) splitD#1#(::(@x,@xs),@pivot) -> c_27(splitD#(@pivot,@xs)) testQuicksort#(@x) -> quicksort#(testList(#unit())) testQuicksort2#(@x) -> quicksort#(testList(#unit())) - Weak TRS: #abs(#0()) -> #0() #abs(#pos(@x)) -> #pos(@x) #ckgt(#EQ()) -> #false() #ckgt(#GT()) -> #true() #ckgt(#LT()) -> #false() #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) #greater(@x,@y) -> #ckgt(#compare(@x,@y)) append(@l,@ys) -> append#1(@l,@ys) append#1(::(@x,@xs),@ys) -> ::(@x,append(@xs,@ys)) append#1(nil(),@ys) -> @ys appendD(@l,@ys) -> appendD#1(@l,@ys) appendD#1(::(@x,@xs),@ys) -> ::(@x,appendD(@xs,@ys)) appendD#1(nil(),@ys) -> @ys quicksort(@l) -> quicksort#1(@l) quicksort#1(::(@z,@zs)) -> quicksort#2(split(@z,@zs),@z) quicksort#1(nil()) -> nil() quicksort#2(tuple#2(@xs,@ys),@z) -> append(quicksort(@xs),::(@z,quicksort(@ys))) quicksortD(@l) -> quicksortD#1(@l) quicksortD#1(::(@z,@zs)) -> quicksortD#2(splitD(@z,@zs),@z) quicksortD#1(nil()) -> nil() quicksortD#2(tuple#2(@xs,@ys),@z) -> appendD(quicksortD(@xs),::(@z,quicksortD(@ys))) split(@pivot,@l) -> split#1(@l,@pivot) split#1(::(@x,@xs),@pivot) -> split#2(split(@pivot,@xs),@pivot,@x) split#1(nil(),@pivot) -> tuple#2(nil(),nil()) split#2(tuple#2(@ls,@rs),@pivot,@x) -> split#3(#greater(@x,@pivot),@ls,@rs,@x) split#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) split#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) splitD(@pivot,@l) -> splitD#1(@l,@pivot) splitD#1(::(@x,@xs),@pivot) -> splitD#2(splitD(@pivot,@xs),@pivot,@x) splitD#1(nil(),@pivot) -> tuple#2(nil(),nil()) splitD#2(tuple#2(@ls,@rs),@pivot,@x) -> splitD#3(#greater(@x,@pivot),@ls,@rs,@x) splitD#3(#false(),@ls,@rs,@x) -> tuple#2(::(@x,@ls),@rs) splitD#3(#true(),@ls,@rs,@x) -> tuple#2(@ls,::(@x,@rs)) testList(@x) -> ::(#abs(#0()) ,::(#abs(#pos(#s(#s(#s(#s(#0())))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#0()))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#s(#0()))))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#0()))))))))) ,::(#abs(#pos(#s(#0()))) ,::(#abs(#pos(#s(#s(#0())))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#s(#s(#0())))))))))) ,::(#abs(#pos(#s(#s(#s(#s(#s(#s(#0())))))))) ,::(#abs(#pos(#s(#s(#s(#0()))))),nil())))))))))) - Signature: {#abs/1,#ckgt/1,#compare/2,#greater/2,append/2,append#1/2,appendD/2,appendD#1/2,quicksort/1,quicksort#1/1 ,quicksort#2/2,quicksortD/1,quicksortD#1/1,quicksortD#2/2,split/2,split#1/2,split#2/3,split#3/4,splitD/2 ,splitD#1/2,splitD#2/3,splitD#3/4,testList/1,testQuicksort/1,testQuicksort2/1,#abs#/1,#ckgt#/1,#compare#/2 ,#greater#/2,append#/2,append#1#/2,appendD#/2,appendD#1#/2,quicksort#/1,quicksort#1#/1,quicksort#2#/2 ,quicksortD#/1,quicksortD#1#/1,quicksortD#2#/2,split#/2,split#1#/2,split#2#/3,split#3#/4,splitD#/2 ,splitD#1#/2,splitD#2#/3,splitD#3#/4,testList#/1,testQuicksort#/1,testQuicksort2#/1} / {#0/0,#EQ/0,#GT/0 ,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,#unit/0,::/2,nil/0,tuple#2/2,c_1/0,c_2/0,c_3/0,c_4/0,c_5/2,c_6/1 ,c_7/1,c_8/0,c_9/1,c_10/1,c_11/0,c_12/1,c_13/2,c_14/0,c_15/3,c_16/1,c_17/2,c_18/0,c_19/3,c_20/1,c_21/1 ,c_22/0,c_23/2,c_24/0,c_25/0,c_26/1,c_27/1,c_28/0,c_29/2,c_30/0,c_31/0,c_32/10,c_33/1,c_34/1,c_35/0,c_36/0 ,c_37/0,c_38/0,c_39/0,c_40/0,c_41/0,c_42/0,c_43/1,c_44/0,c_45/0,c_46/0,c_47/1,c_48/0,c_49/1} - Obligation: innermost runtime complexity wrt. defined symbols {#abs#,#ckgt#,#compare#,#greater#,append#,append#1# ,appendD#,appendD#1#,quicksort#,quicksort#1#,quicksort#2#,quicksortD#,quicksortD#1#,quicksortD#2#,split# ,split#1#,split#2#,split#3#,splitD#,splitD#1#,splitD#2#,splitD#3#,testList#,testQuicksort# ,testQuicksort2#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,#unit,::,nil,tuple#2} + Applied Processor: Ara {minDegree = 1, maxDegree = 2, araTimeout = 8, araRuleShifting = Just 1, isBestCase = False, mkCompletelyDefined = False, verboseOutput = False} + Details: Signatures used: ---------------- F (TrsFun "#0") :: [] -(0)-> "A"(0) F (TrsFun "#0") :: [] -(0)-> "A"(8) F (TrsFun "#0") :: [] -(0)-> "A"(13) F (TrsFun "#0") :: [] -(0)-> "A"(10) F (TrsFun "#0") :: [] -(0)-> "A"(12) F (TrsFun "#EQ") :: [] -(0)-> "A"(0) F (TrsFun "#GT") :: [] -(0)-> "A"(0) F (TrsFun "#LT") :: [] -(0)-> "A"(0) F (TrsFun "#abs") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#ckgt") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#compare") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "#false") :: [] -(0)-> "A"(0) F (TrsFun "#greater") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "#neg") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(8) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(4) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(6) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(12) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(2) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(1) F (TrsFun "#pos") :: ["A"(0)] -(0)-> "A"(9) F (TrsFun "#s") :: ["A"(0)] -(0)-> "A"(0) F (TrsFun "#s") :: ["A"(5)] -(0)-> "A"(5) F (TrsFun "#s") :: ["A"(8)] -(0)-> "A"(8) F (TrsFun "#s") :: ["A"(13)] -(0)-> "A"(13) F (TrsFun "#s") :: ["A"(4)] -(0)-> "A"(4) F (TrsFun "#s") :: ["A"(10)] -(0)-> "A"(10) F (TrsFun "#s") :: ["A"(2)] -(0)-> "A"(2) F (TrsFun "#s") :: ["A"(1)] -(0)-> "A"(1) F (TrsFun "#s") :: ["A"(12)] -(0)-> "A"(12) F (TrsFun "#true") :: [] -(0)-> "A"(0) F (TrsFun "#unit") :: [] -(0)-> "A"(0) F (TrsFun "::") :: ["A"(0) x "A"(1)] -(1)-> "A"(1) F (TrsFun "::") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "::") :: ["A"(0) x "A"(5)] -(5)-> "A"(5) F (TrsFun "::") :: ["A"(0) x "A"(2)] -(2)-> "A"(2) F (TrsFun "append") :: ["A"(1) x "A"(1)] -(0)-> "A"(1) F (TrsFun "append#1") :: ["A"(1) x "A"(1)] -(0)-> "A"(1) F (TrsFun "appendD") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "appendD#1") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "nil") :: [] -(0)-> "A"(1) F (TrsFun "nil") :: [] -(0)-> "A"(0) F (TrsFun "nil") :: [] -(0)-> "A"(5) F (TrsFun "nil") :: [] -(0)-> "A"(11) F (TrsFun "nil") :: [] -(0)-> "A"(7) F (TrsFun "nil") :: [] -(0)-> "A"(14) F (TrsFun "nil") :: [] -(0)-> "A"(15) F (TrsFun "quicksort") :: ["A"(1)] -(0)-> "A"(1) F (TrsFun "quicksort#1") :: ["A"(1)] -(0)-> "A"(1) F (TrsFun "quicksort#2") :: ["A"(1) x "A"(0)] -(1)-> "A"(1) F (TrsFun "quicksortD") :: ["A"(5)] -(3)-> "A"(0) F (TrsFun "quicksortD#1") :: ["A"(5)] -(3)-> "A"(0) F (TrsFun "quicksortD#2") :: ["A"(5) x "A"(0)] -(6)-> "A"(0) F (TrsFun "split") :: ["A"(0) x "A"(1)] -(0)-> "A"(1) F (TrsFun "split#1") :: ["A"(1) x "A"(0)] -(0)-> "A"(1) F (TrsFun "split#2") :: ["A"(1) x "A"(0) x "A"(0)] -(1)-> "A"(1) F (TrsFun "split#3") :: ["A"(0) x "A"(1) x "A"(1) x "A"(0)] -(1)-> "A"(1) F (TrsFun "splitD") :: ["A"(0) x "A"(5)] -(0)-> "A"(5) F (TrsFun "splitD#1") :: ["A"(5) x "A"(0)] -(0)-> "A"(5) F (TrsFun "splitD#2") :: ["A"(5) x "A"(0) x "A"(0)] -(5)-> "A"(5) F (TrsFun "splitD#3") :: ["A"(0) x "A"(5) x "A"(5) x "A"(0)] -(5)-> "A"(5) F (TrsFun "testList") :: ["A"(0)] -(14)-> "A"(1) F (TrsFun "tuple#2") :: ["A"(1) x "A"(1)] -(0)-> "A"(1) F (TrsFun "tuple#2") :: ["A"(5) x "A"(5)] -(0)-> "A"(5) F (TrsFun "tuple#2") :: ["A"(14) x "A"(14)] -(0)-> "A"(14) F (TrsFun "tuple#2") :: ["A"(7) x "A"(7)] -(0)-> "A"(7) F (DpFun "append") :: ["A"(1) x "A"(0)] -(1)-> "A"(8) F (DpFun "append#1") :: ["A"(1) x "A"(0)] -(0)-> "A"(0) F (DpFun "appendD") :: ["A"(0) x "A"(0)] -(0)-> "A"(6) F (DpFun "appendD#1") :: ["A"(0) x "A"(0)] -(0)-> "A"(2) F (DpFun "quicksort") :: ["A"(1)] -(1)-> "A"(0) F (DpFun "quicksort#1") :: ["A"(1)] -(1)-> "A"(0) F (DpFun "quicksort#2") :: ["A"(1) x "A"(0)] -(2)-> "A"(0) F (DpFun "quicksortD") :: ["A"(5)] -(12)-> "A"(1) F (DpFun "quicksortD#1") :: ["A"(5)] -(12)-> "A"(1) F (DpFun "quicksortD#2") :: ["A"(5) x "A"(0)] -(12)-> "A"(1) F (DpFun "split") :: ["A"(0) x "A"(0)] -(0)-> "A"(6) F (DpFun "split#1") :: ["A"(0) x "A"(0)] -(0)-> "A"(14) F (DpFun "splitD") :: ["A"(0) x "A"(2)] -(6)-> "A"(1) F (DpFun "splitD#1") :: ["A"(2) x "A"(0)] -(4)-> "A"(14) F (DpFun "testQuicksort") :: ["A"(0)] -(15)-> "A"(0) F (DpFun "testQuicksort2") :: ["A"(0)] -(15)-> "A"(0) F (ComFun 6) :: ["A"(0)] -(0)-> "A"(13) F (ComFun 7) :: ["A"(0)] -(0)-> "A"(13) F (ComFun 9) :: ["A"(0)] -(0)-> "A"(7) F (ComFun 10) :: ["A"(0)] -(0)-> "A"(3) F (ComFun 20) :: ["A"(0)] -(0)-> "A"(7) F (ComFun 21) :: ["A"(0)] -(0)-> "A"(15) F (ComFun 26) :: ["A"(12)] -(0)-> "A"(12) F (ComFun 27) :: ["A"(0)] -(0)-> "A"(15) Cost-free Signatures used: -------------------------- Base Constructor Signatures used: --------------------------------- "F (ComFun 10)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 20)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 21)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 26)_A" :: ["A"(1)] -(0)-> "A"(1) "F (ComFun 27)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 6)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 7)_A" :: ["A"(0)] -(0)-> "A"(1) "F (ComFun 9)_A" :: ["A"(0)] -(0)-> "A"(1) "F (TrsFun \"#0\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#EQ\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#GT\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#LT\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#false\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#neg\")_A" :: ["A"(1)] -(0)-> "A"(1) "F (TrsFun \"#pos\")_A" :: ["A"(0)] -(0)-> "A"(1) "F (TrsFun \"#s\")_A" :: ["A"(1)] -(0)-> "A"(1) "F (TrsFun \"#true\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"#unit\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"::\")_A" :: ["A"(0) x "A"(1)] -(1)-> "A"(1) "F (TrsFun \"nil\")_A" :: [] -(0)-> "A"(1) "F (TrsFun \"tuple#2\")_A" :: ["A"(1) x "A"(1)] -(0)-> "A"(1) Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: append#(@l,@ys) -> c_6(append#1#(@l,@ys)) 2. Weak: WORST_CASE(?,O(n^2))