MAYBE * Step 1: DependencyPairs MAYBE + Considered Problem: - Strict TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) computeLine(line,m,acc) -> computeLine'1(line,acc,m) computeLine'1(dd(x,xs),acc,m) -> computeLine'2(m,acc,x,xs) computeLine'1(nil(),acc,m) -> acc computeLine'2(dd(l,ls),acc,x,xs) -> computeLine(xs,ls,lineMult(x,l,acc)) computeLine'2(nil(),acc,x,xs) -> nil() lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) matrixMult(m1,m2) -> matrixMult'1(m1,m2) matrixMult'1(dd(l,ls),m2) -> dd(computeLine(l,m2,nil()),matrixMult(ls,m2)) matrixMult'1(nil(),m2) -> nil() mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2 ,nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {'add,'mult,'natadd,'natmult,'pred,'succ,add,computeLine ,computeLine'1,computeLine'2,lineMult,lineMult'1,lineMult'2,matrixMult,matrixMult'1 ,mult} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: DependencyPairs {dpKind_ = DT} + Details: We add the following dependency tuples: Strict DPs 'add#('0(),y) -> c_1() 'add#('neg('s('0())),y) -> c_2('pred#(y)) 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'add#('pos('s('0())),y) -> c_4('succ#(y)) 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'mult#('0(),'0()) -> c_6() 'mult#('0(),'neg(y)) -> c_7() 'mult#('0(),'pos(y)) -> c_8() 'mult#('neg(x),'0()) -> c_9() 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'0()) -> c_12() 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('0(),y) -> c_15() 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('0(),y) -> c_17() 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 'pred#('0()) -> c_19() 'pred#('neg('s(x))) -> c_20() 'pred#('pos('s('0()))) -> c_21() 'pred#('pos('s('s(x)))) -> c_22() 'succ#('0()) -> c_23() 'succ#('neg('s('0()))) -> c_24() 'succ#('neg('s('s(x)))) -> c_25() 'succ#('pos('s(x))) -> c_26() add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'1#(nil(),acc,m) -> c_30() computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) computeLine'2#(nil(),acc,x,xs) -> c_32() lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'1#(nil(),l2,n) -> c_35() lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) matrixMult'1#(nil(),m2) -> c_40() mult#(x,y) -> c_41('mult#(x,y)) Weak DPs and mark the set of starting terms. * Step 2: UsableRules MAYBE + Considered Problem: - Strict DPs: 'add#('0(),y) -> c_1() 'add#('neg('s('0())),y) -> c_2('pred#(y)) 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'add#('pos('s('0())),y) -> c_4('succ#(y)) 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'mult#('0(),'0()) -> c_6() 'mult#('0(),'neg(y)) -> c_7() 'mult#('0(),'pos(y)) -> c_8() 'mult#('neg(x),'0()) -> c_9() 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'0()) -> c_12() 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('0(),y) -> c_15() 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('0(),y) -> c_17() 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 'pred#('0()) -> c_19() 'pred#('neg('s(x))) -> c_20() 'pred#('pos('s('0()))) -> c_21() 'pred#('pos('s('s(x)))) -> c_22() 'succ#('0()) -> c_23() 'succ#('neg('s('0()))) -> c_24() 'succ#('neg('s('s(x)))) -> c_25() 'succ#('pos('s(x))) -> c_26() add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'1#(nil(),acc,m) -> c_30() computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) computeLine'2#(nil(),acc,x,xs) -> c_32() lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'1#(nil(),l2,n) -> c_35() lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) matrixMult'1#(nil(),m2) -> c_40() mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) computeLine(line,m,acc) -> computeLine'1(line,acc,m) computeLine'1(dd(x,xs),acc,m) -> computeLine'2(m,acc,x,xs) computeLine'1(nil(),acc,m) -> acc computeLine'2(dd(l,ls),acc,x,xs) -> computeLine(xs,ls,lineMult(x,l,acc)) computeLine'2(nil(),acc,x,xs) -> nil() lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) matrixMult(m1,m2) -> matrixMult'1(m1,m2) matrixMult'1(dd(l,ls),m2) -> dd(computeLine(l,m2,nil()),matrixMult(ls,m2)) matrixMult'1(nil(),m2) -> nil() mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/2,c_4/1,c_5/2,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: UsableRules + Details: We replace rewrite rules by usable rules: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) 'add#('0(),y) -> c_1() 'add#('neg('s('0())),y) -> c_2('pred#(y)) 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'add#('pos('s('0())),y) -> c_4('succ#(y)) 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'mult#('0(),'0()) -> c_6() 'mult#('0(),'neg(y)) -> c_7() 'mult#('0(),'pos(y)) -> c_8() 'mult#('neg(x),'0()) -> c_9() 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'0()) -> c_12() 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('0(),y) -> c_15() 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('0(),y) -> c_17() 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 'pred#('0()) -> c_19() 'pred#('neg('s(x))) -> c_20() 'pred#('pos('s('0()))) -> c_21() 'pred#('pos('s('s(x)))) -> c_22() 'succ#('0()) -> c_23() 'succ#('neg('s('0()))) -> c_24() 'succ#('neg('s('s(x)))) -> c_25() 'succ#('pos('s(x))) -> c_26() add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'1#(nil(),acc,m) -> c_30() computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) computeLine'2#(nil(),acc,x,xs) -> c_32() lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'1#(nil(),l2,n) -> c_35() lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) matrixMult'1#(nil(),m2) -> c_40() mult#(x,y) -> c_41('mult#(x,y)) * Step 3: PredecessorEstimation MAYBE + Considered Problem: - Strict DPs: 'add#('0(),y) -> c_1() 'add#('neg('s('0())),y) -> c_2('pred#(y)) 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'add#('pos('s('0())),y) -> c_4('succ#(y)) 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'mult#('0(),'0()) -> c_6() 'mult#('0(),'neg(y)) -> c_7() 'mult#('0(),'pos(y)) -> c_8() 'mult#('neg(x),'0()) -> c_9() 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'0()) -> c_12() 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('0(),y) -> c_15() 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('0(),y) -> c_17() 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 'pred#('0()) -> c_19() 'pred#('neg('s(x))) -> c_20() 'pred#('pos('s('0()))) -> c_21() 'pred#('pos('s('s(x)))) -> c_22() 'succ#('0()) -> c_23() 'succ#('neg('s('0()))) -> c_24() 'succ#('neg('s('s(x)))) -> c_25() 'succ#('pos('s(x))) -> c_26() add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'1#(nil(),acc,m) -> c_30() computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) computeLine'2#(nil(),acc,x,xs) -> c_32() lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'1#(nil(),l2,n) -> c_35() lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) matrixMult'1#(nil(),m2) -> c_40() mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/2,c_4/1,c_5/2,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {1,6,7,8,9,12,15,17,19,20,21,22,23,24,25,26,30,32,35,40} by application of Pre({1,6,7,8,9,12,15,17,19,20,21,22,23,24,25,26,30,32,35,40}) = {2,3,4,5,10,11,13,14,16,18,27,28,29,33,38 ,41}. Here rules are labelled as follows: 1: 'add#('0(),y) -> c_1() 2: 'add#('neg('s('0())),y) -> c_2('pred#(y)) 3: 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 4: 'add#('pos('s('0())),y) -> c_4('succ#(y)) 5: 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 6: 'mult#('0(),'0()) -> c_6() 7: 'mult#('0(),'neg(y)) -> c_7() 8: 'mult#('0(),'pos(y)) -> c_8() 9: 'mult#('neg(x),'0()) -> c_9() 10: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 11: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 12: 'mult#('pos(x),'0()) -> c_12() 13: 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 14: 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 15: 'natadd#('0(),y) -> c_15() 16: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 17: 'natmult#('0(),y) -> c_17() 18: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 19: 'pred#('0()) -> c_19() 20: 'pred#('neg('s(x))) -> c_20() 21: 'pred#('pos('s('0()))) -> c_21() 22: 'pred#('pos('s('s(x)))) -> c_22() 23: 'succ#('0()) -> c_23() 24: 'succ#('neg('s('0()))) -> c_24() 25: 'succ#('neg('s('s(x)))) -> c_25() 26: 'succ#('pos('s(x))) -> c_26() 27: add#(x,y) -> c_27('add#(x,y)) 28: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 29: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 30: computeLine'1#(nil(),acc,m) -> c_30() 31: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 32: computeLine'2#(nil(),acc,x,xs) -> c_32() 33: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 34: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 35: lineMult'1#(nil(),l2,n) -> c_35() 36: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) 37: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) 38: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 39: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) 40: matrixMult'1#(nil(),m2) -> c_40() 41: mult#(x,y) -> c_41('mult#(x,y)) * Step 4: PredecessorEstimation MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('0())),y) -> c_2('pred#(y)) 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'add#('pos('s('0())),y) -> c_4('succ#(y)) 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak DPs: 'add#('0(),y) -> c_1() 'mult#('0(),'0()) -> c_6() 'mult#('0(),'neg(y)) -> c_7() 'mult#('0(),'pos(y)) -> c_8() 'mult#('neg(x),'0()) -> c_9() 'mult#('pos(x),'0()) -> c_12() 'natadd#('0(),y) -> c_15() 'natmult#('0(),y) -> c_17() 'pred#('0()) -> c_19() 'pred#('neg('s(x))) -> c_20() 'pred#('pos('s('0()))) -> c_21() 'pred#('pos('s('s(x)))) -> c_22() 'succ#('0()) -> c_23() 'succ#('neg('s('0()))) -> c_24() 'succ#('neg('s('s(x)))) -> c_25() 'succ#('pos('s(x))) -> c_26() computeLine'1#(nil(),acc,m) -> c_30() computeLine'2#(nil(),acc,x,xs) -> c_32() lineMult'1#(nil(),l2,n) -> c_35() matrixMult'1#(nil(),m2) -> c_40() - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/2,c_4/1,c_5/2,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {1,3} by application of Pre({1,3}) = {2,4,11}. Here rules are labelled as follows: 1: 'add#('neg('s('0())),y) -> c_2('pred#(y)) 2: 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 3: 'add#('pos('s('0())),y) -> c_4('succ#(y)) 4: 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 5: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 6: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 7: 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 8: 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 9: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 10: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 11: add#(x,y) -> c_27('add#(x,y)) 12: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 13: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 14: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 15: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 16: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 17: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) 18: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) 19: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 20: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) 21: mult#(x,y) -> c_41('mult#(x,y)) 22: 'add#('0(),y) -> c_1() 23: 'mult#('0(),'0()) -> c_6() 24: 'mult#('0(),'neg(y)) -> c_7() 25: 'mult#('0(),'pos(y)) -> c_8() 26: 'mult#('neg(x),'0()) -> c_9() 27: 'mult#('pos(x),'0()) -> c_12() 28: 'natadd#('0(),y) -> c_15() 29: 'natmult#('0(),y) -> c_17() 30: 'pred#('0()) -> c_19() 31: 'pred#('neg('s(x))) -> c_20() 32: 'pred#('pos('s('0()))) -> c_21() 33: 'pred#('pos('s('s(x)))) -> c_22() 34: 'succ#('0()) -> c_23() 35: 'succ#('neg('s('0()))) -> c_24() 36: 'succ#('neg('s('s(x)))) -> c_25() 37: 'succ#('pos('s(x))) -> c_26() 38: computeLine'1#(nil(),acc,m) -> c_30() 39: computeLine'2#(nil(),acc,x,xs) -> c_32() 40: lineMult'1#(nil(),l2,n) -> c_35() 41: matrixMult'1#(nil(),m2) -> c_40() * Step 5: RemoveWeakSuffixes MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak DPs: 'add#('0(),y) -> c_1() 'add#('neg('s('0())),y) -> c_2('pred#(y)) 'add#('pos('s('0())),y) -> c_4('succ#(y)) 'mult#('0(),'0()) -> c_6() 'mult#('0(),'neg(y)) -> c_7() 'mult#('0(),'pos(y)) -> c_8() 'mult#('neg(x),'0()) -> c_9() 'mult#('pos(x),'0()) -> c_12() 'natadd#('0(),y) -> c_15() 'natmult#('0(),y) -> c_17() 'pred#('0()) -> c_19() 'pred#('neg('s(x))) -> c_20() 'pred#('pos('s('0()))) -> c_21() 'pred#('pos('s('s(x)))) -> c_22() 'succ#('0()) -> c_23() 'succ#('neg('s('0()))) -> c_24() 'succ#('neg('s('s(x)))) -> c_25() 'succ#('pos('s(x))) -> c_26() computeLine'1#(nil(),acc,m) -> c_30() computeLine'2#(nil(),acc,x,xs) -> c_32() lineMult'1#(nil(),l2,n) -> c_35() matrixMult'1#(nil(),m2) -> c_40() - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/2,c_4/1,c_5/2,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) -->_2 'add#('pos('s('0())),y) -> c_4('succ#(y)):22 -->_2 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)):2 -->_1 'pred#('pos('s('s(x)))) -> c_22():33 -->_1 'pred#('pos('s('0()))) -> c_21():32 -->_1 'pred#('neg('s(x))) -> c_20():31 -->_1 'pred#('0()) -> c_19():30 2:S:'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) -->_2 'add#('pos('s('0())),y) -> c_4('succ#(y)):22 -->_1 'succ#('pos('s(x))) -> c_26():37 -->_1 'succ#('neg('s('s(x)))) -> c_25():36 -->_1 'succ#('neg('s('0()))) -> c_24():35 -->_1 'succ#('0()) -> c_23():34 -->_2 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)):2 3:S:'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 -->_1 'natmult#('0(),y) -> c_17():29 4:S:'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 -->_1 'natmult#('0(),y) -> c_17():29 5:S:'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 -->_1 'natmult#('0(),y) -> c_17():29 6:S:'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 -->_1 'natmult#('0(),y) -> c_17():29 7:S:'natadd#('s(x),y) -> c_16('natadd#(x,y)) -->_1 'natadd#('0(),y) -> c_15():28 -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):7 8:S:'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) -->_2 'natmult#('0(),y) -> c_17():29 -->_1 'natadd#('0(),y) -> c_15():28 -->_2 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):7 9:S:add#(x,y) -> c_27('add#(x,y)) -->_1 'add#('pos('s('0())),y) -> c_4('succ#(y)):22 -->_1 'add#('neg('s('0())),y) -> c_2('pred#(y)):21 -->_1 'add#('0(),y) -> c_1():20 -->_1 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)):2 -->_1 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)):1 10:S:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):11 -->_1 computeLine'1#(nil(),acc,m) -> c_30():38 11:S:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):12 -->_1 computeLine'2#(nil(),acc,x,xs) -> c_32():39 12:S:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):10 13:S:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):14 -->_1 lineMult'1#(nil(),l2,n) -> c_35():40 14:S:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):16 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)):15 15:S:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) -->_2 mult#(x,y) -> c_41('mult#(x,y)):19 -->_3 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 -->_1 add#(x,y) -> c_27('add#(x,y)):9 16:S:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_1 mult#(x,y) -> c_41('mult#(x,y)):19 -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 17:S:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):18 -->_1 matrixMult'1#(nil(),m2) -> c_40():41 18:S:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):17 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):10 19:S:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('pos(x),'0()) -> c_12():27 -->_1 'mult#('neg(x),'0()) -> c_9():26 -->_1 'mult#('0(),'pos(y)) -> c_8():25 -->_1 'mult#('0(),'neg(y)) -> c_7():24 -->_1 'mult#('0(),'0()) -> c_6():23 -->_1 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)):6 -->_1 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)):5 -->_1 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)):4 -->_1 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)):3 20:W:'add#('0(),y) -> c_1() 21:W:'add#('neg('s('0())),y) -> c_2('pred#(y)) -->_1 'pred#('pos('s('s(x)))) -> c_22():33 -->_1 'pred#('pos('s('0()))) -> c_21():32 -->_1 'pred#('neg('s(x))) -> c_20():31 -->_1 'pred#('0()) -> c_19():30 22:W:'add#('pos('s('0())),y) -> c_4('succ#(y)) -->_1 'succ#('pos('s(x))) -> c_26():37 -->_1 'succ#('neg('s('s(x)))) -> c_25():36 -->_1 'succ#('neg('s('0()))) -> c_24():35 -->_1 'succ#('0()) -> c_23():34 23:W:'mult#('0(),'0()) -> c_6() 24:W:'mult#('0(),'neg(y)) -> c_7() 25:W:'mult#('0(),'pos(y)) -> c_8() 26:W:'mult#('neg(x),'0()) -> c_9() 27:W:'mult#('pos(x),'0()) -> c_12() 28:W:'natadd#('0(),y) -> c_15() 29:W:'natmult#('0(),y) -> c_17() 30:W:'pred#('0()) -> c_19() 31:W:'pred#('neg('s(x))) -> c_20() 32:W:'pred#('pos('s('0()))) -> c_21() 33:W:'pred#('pos('s('s(x)))) -> c_22() 34:W:'succ#('0()) -> c_23() 35:W:'succ#('neg('s('0()))) -> c_24() 36:W:'succ#('neg('s('s(x)))) -> c_25() 37:W:'succ#('pos('s(x))) -> c_26() 38:W:computeLine'1#(nil(),acc,m) -> c_30() 39:W:computeLine'2#(nil(),acc,x,xs) -> c_32() 40:W:lineMult'1#(nil(),l2,n) -> c_35() 41:W:matrixMult'1#(nil(),m2) -> c_40() The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 41: matrixMult'1#(nil(),m2) -> c_40() 38: computeLine'1#(nil(),acc,m) -> c_30() 39: computeLine'2#(nil(),acc,x,xs) -> c_32() 40: lineMult'1#(nil(),l2,n) -> c_35() 23: 'mult#('0(),'0()) -> c_6() 24: 'mult#('0(),'neg(y)) -> c_7() 25: 'mult#('0(),'pos(y)) -> c_8() 26: 'mult#('neg(x),'0()) -> c_9() 27: 'mult#('pos(x),'0()) -> c_12() 20: 'add#('0(),y) -> c_1() 21: 'add#('neg('s('0())),y) -> c_2('pred#(y)) 28: 'natadd#('0(),y) -> c_15() 29: 'natmult#('0(),y) -> c_17() 30: 'pred#('0()) -> c_19() 31: 'pred#('neg('s(x))) -> c_20() 32: 'pred#('pos('s('0()))) -> c_21() 33: 'pred#('pos('s('s(x)))) -> c_22() 22: 'add#('pos('s('0())),y) -> c_4('succ#(y)) 34: 'succ#('0()) -> c_23() 35: 'succ#('neg('s('0()))) -> c_24() 36: 'succ#('neg('s('s(x)))) -> c_25() 37: 'succ#('pos('s(x))) -> c_26() * Step 6: SimplifyRHS MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/2,c_4/1,c_5/2,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) -->_2 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)):2 2:S:'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)) -->_2 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)):2 3:S:'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 4:S:'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 5:S:'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 6:S:'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 7:S:'natadd#('s(x),y) -> c_16('natadd#(x,y)) -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):7 8:S:'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) -->_2 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):7 9:S:add#(x,y) -> c_27('add#(x,y)) -->_1 'add#('pos('s('s(x))),y) -> c_5('succ#('add('pos('s(x)),y)),'add#('pos('s(x)),y)):2 -->_1 'add#('neg('s('s(x))),y) -> c_3('pred#('add('pos('s(x)),y)),'add#('pos('s(x)),y)):1 10:S:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):11 11:S:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):12 12:S:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):10 13:S:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):14 14:S:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):16 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)):15 15:S:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) -->_2 mult#(x,y) -> c_41('mult#(x,y)):19 -->_3 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 -->_1 add#(x,y) -> c_27('add#(x,y)):9 16:S:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_1 mult#(x,y) -> c_41('mult#(x,y)):19 -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 17:S:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):18 18:S:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):17 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):10 19:S:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)):6 -->_1 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)):5 -->_1 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)):4 -->_1 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)):3 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) * Step 7: Decompose MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd} + Details: We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component. Problem (R) - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} Problem (S) - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} ** Step 7.a:1: RemoveWeakSuffixes MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):2 2:S:'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):2 3:W:'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 4:W:'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 5:W:'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 6:W:'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 7:W:'natadd#('s(x),y) -> c_16('natadd#(x,y)) -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):7 8:W:'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):7 -->_2 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):8 9:W:add#(x,y) -> c_27('add#(x,y)) -->_1 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)):1 -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):2 10:W:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):11 11:W:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):12 12:W:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):10 -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 13:W:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):14 14:W:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):16 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)):15 15:W:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) -->_1 add#(x,y) -> c_27('add#(x,y)):9 -->_3 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 -->_2 mult#(x,y) -> c_41('mult#(x,y)):19 16:W:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 -->_1 mult#(x,y) -> c_41('mult#(x,y)):19 17:W:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):18 18:W:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):10 -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):17 19:W:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)):3 -->_1 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)):4 -->_1 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)):5 -->_1 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)):6 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 19: mult#(x,y) -> c_41('mult#(x,y)) 6: 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 5: 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 4: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 3: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 8: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 7: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) ** Step 7.a:2: SimplifyRHS MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak DPs: add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):2 2:S:'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):2 9:W:add#(x,y) -> c_27('add#(x,y)) -->_1 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)):1 -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):2 10:W:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):11 11:W:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):12 12:W:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):10 -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 13:W:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):14 14:W:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):16 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)):15 15:W:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) -->_1 add#(x,y) -> c_27('add#(x,y)):9 -->_3 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 16:W:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):13 17:W:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):18 18:W:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):10 -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):17 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) ** Step 7.a:3: DecomposeDG MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak DPs: add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing} + Details: We decompose the input problem according to the dependency graph into the upper component matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) and a lower component 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) Further, following extension rules are added to the lower component. matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) *** Step 7.a:3.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) Consider the set of all dependency pairs 1: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) 2: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1)) SPACE(?,?)on application of the dependency pairs {1} These cover all (indirect) predecessors of dependency pairs {1,2} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. **** Step 7.a:3.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_38) = {1}, uargs(c_39) = {2} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [0] p('add) = [0] p('mult) = [0] p('natadd) = [1] x1 + [0] p('natmult) = [0] p('neg) = [0] p('pos) = [1] x1 + [0] p('pred) = [1] x1 + [0] p('s) = [1] x1 + [0] p('succ) = [0] p(add) = [1] x1 + [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x2 + [1] p(lineMult) = [5] x3 + [0] p(lineMult'1) = [0] p(lineMult'2) = [5] p(matrixMult) = [1] x2 + [0] p(matrixMult'1) = [0] p(mult) = [1] x1 + [1] x2 + [0] p(nil) = [1] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [0] p(computeLine'1#) = [0] p(computeLine'2#) = [0] p(lineMult#) = [0] p(lineMult'1#) = [4] x1 + [0] p(lineMult'2#) = [0] p(matrixMult#) = [2] x1 + [4] x2 + [0] p(matrixMult'1#) = [2] x1 + [4] x2 + [0] p(mult#) = [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [2] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [1] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [0] p(c_18) = [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [0] p(c_28) = [0] p(c_29) = [0] p(c_30) = [0] p(c_31) = [0] p(c_32) = [0] p(c_33) = [0] p(c_34) = [0] p(c_35) = [0] p(c_36) = [0] p(c_37) = [0] p(c_38) = [1] x1 + [0] p(c_39) = [1] x2 + [0] p(c_40) = [0] p(c_41) = [1] x1 + [0] Following rules are strictly oriented: matrixMult'1#(dd(l,ls),m2) = [2] ls + [4] m2 + [2] > [2] ls + [4] m2 + [0] = c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) Following rules are (at-least) weakly oriented: matrixMult#(m1,m2) = [2] m1 + [4] m2 + [0] >= [2] m1 + [4] m2 + [0] = c_38(matrixMult'1#(m1,m2)) **** Step 7.a:3.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () **** Step 7.a:3.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):2 2:W:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 1: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 2: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) **** Step 7.a:3.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). *** Step 7.a:3.b:1: DecomposeDG MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak DPs: add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing} + Details: We decompose the input problem according to the dependency graph into the upper component computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) and a lower component 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) add#(x,y) -> c_27('add#(x,y)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) Further, following extension rules are added to the lower component. computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) **** Step 7.a:3.b:1.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) The strictly oriented rules are moved into the weak component. ***** Step 7.a:3.b:1.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_28) = {1}, uargs(c_29) = {1}, uargs(c_31) = {1} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [0] p('add) = [1] p('mult) = [0] p('natadd) = [0] p('natmult) = [0] p('neg) = [0] p('pos) = [1] x1 + [0] p('pred) = [1] x1 + [0] p('s) = [0] p('succ) = [0] p(add) = [1] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [1] p(lineMult) = [1] x1 + [4] p(lineMult'1) = [0] p(lineMult'2) = [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [4] p(nil) = [0] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [2] x2 + [0] p(computeLine'1#) = [2] x3 + [0] p(computeLine'2#) = [2] x1 + [0] p(lineMult#) = [2] x2 + [1] p(lineMult'1#) = [0] p(lineMult'2#) = [0] p(matrixMult#) = [5] x1 + [3] x2 + [2] p(matrixMult'1#) = [5] x1 + [3] x2 + [1] p(mult#) = [0] p(c_1) = [0] p(c_2) = [1] x1 + [0] p(c_3) = [0] p(c_4) = [2] x1 + [0] p(c_5) = [0] p(c_6) = [1] p(c_7) = [2] p(c_8) = [1] p(c_9) = [0] p(c_10) = [2] x1 + [4] p(c_11) = [0] p(c_12) = [4] p(c_13) = [0] p(c_14) = [4] x1 + [0] p(c_15) = [2] p(c_16) = [1] x1 + [0] p(c_17) = [0] p(c_18) = [1] x1 + [4] p(c_19) = [0] p(c_20) = [0] p(c_21) = [1] p(c_22) = [1] p(c_23) = [4] p(c_24) = [0] p(c_25) = [2] p(c_26) = [1] p(c_27) = [0] p(c_28) = [1] x1 + [0] p(c_29) = [1] x1 + [0] p(c_30) = [1] p(c_31) = [1] x1 + [1] x2 + [0] p(c_32) = [0] p(c_33) = [1] x1 + [1] p(c_34) = [1] p(c_35) = [0] p(c_36) = [1] x2 + [0] p(c_37) = [0] p(c_38) = [4] x1 + [0] p(c_39) = [1] x2 + [2] p(c_40) = [2] p(c_41) = [4] x1 + [1] Following rules are strictly oriented: computeLine'2#(dd(l,ls),acc,x,xs) = [2] l + [2] ls + [2] > [2] l + [2] ls + [1] = c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) Following rules are (at-least) weakly oriented: computeLine#(line,m,acc) = [2] m + [0] >= [2] m + [0] = c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) = [2] m + [0] >= [2] m + [0] = c_29(computeLine'2#(m,acc,x,xs)) matrixMult#(m1,m2) = [5] m1 + [3] m2 + [2] >= [5] m1 + [3] m2 + [1] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [5] l + [5] ls + [3] m2 + [6] >= [2] m2 + [0] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [5] l + [5] ls + [3] m2 + [6] >= [5] ls + [3] m2 + [2] = matrixMult#(ls,m2) ***** Step 7.a:3.b:1.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ***** Step 7.a:3.b:1.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):2 2:W:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):3 3:W:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 4:W:matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) -->_1 matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2):6 -->_1 matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()):5 5:W:matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 6:W:matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) -->_1 matrixMult#(m1,m2) -> matrixMult'1#(m1,m2):4 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 4: matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) 6: matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) 5: matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) 1: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 2: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) ***** Step 7.a:3.b:1.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). **** Step 7.a:3.b:1.b:1: DecomposeDG MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak DPs: add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing} + Details: We decompose the input problem according to the dependency graph into the upper component computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) and a lower component 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) add#(x,y) -> c_27('add#(x,y)) Further, following extension rules are added to the lower component. computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> add#(mult(x,n),y) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) ***** Step 7.a:3.b:1.b:1.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) The strictly oriented rules are moved into the weak component. ****** Step 7.a:3.b:1.b:1.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_33) = {1}, uargs(c_34) = {1}, uargs(c_36) = {1,2}, uargs(c_37) = {1} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [1] p('add) = [0] p('mult) = [4] x1 + [1] x2 + [0] p('natadd) = [2] x2 + [0] p('natmult) = [1] x1 + [1] x2 + [2] p('neg) = [0] p('pos) = [1] x1 + [3] p('pred) = [1] x1 + [0] p('s) = [5] p('succ) = [0] p(add) = [1] x1 + [4] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [1] p(lineMult) = [1] x3 + [0] p(lineMult'1) = [0] p(lineMult'2) = [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [7] p(nil) = [2] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [1] x2 + [4] p(computeLine'1#) = [1] x3 + [4] p(computeLine'2#) = [1] x1 + [3] p(lineMult#) = [1] x2 + [1] p(lineMult'1#) = [1] x1 + [1] p(lineMult'2#) = [1] x3 + [1] x4 + [2] p(matrixMult#) = [4] x1 + [1] x2 + [5] p(matrixMult'1#) = [4] x1 + [1] x2 + [5] p(mult#) = [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [0] p(c_18) = [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [0] p(c_28) = [0] p(c_29) = [0] p(c_30) = [0] p(c_31) = [1] x2 + [0] p(c_32) = [0] p(c_33) = [1] x1 + [0] p(c_34) = [1] x1 + [0] p(c_35) = [0] p(c_36) = [1] x1 + [1] x2 + [0] p(c_37) = [1] x1 + [0] p(c_38) = [0] p(c_39) = [1] x1 + [1] x2 + [0] p(c_40) = [0] p(c_41) = [1] x1 + [0] Following rules are strictly oriented: lineMult'2#(dd(y,ys),n,x,xs) = [1] x + [1] xs + [2] > [1] xs + [1] = c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) Following rules are (at-least) weakly oriented: computeLine#(line,m,acc) = [1] m + [4] >= [1] m + [4] = computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) = [1] m + [4] >= [1] m + [3] = computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) = [1] l + [1] ls + [4] >= [1] ls + [4] = computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) = [1] l + [1] ls + [4] >= [1] l + [1] = lineMult#(x,l,acc) lineMult#(n,l1,l2) = [1] l1 + [1] >= [1] l1 + [1] = c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) = [1] x + [1] xs + [2] >= [1] x + [1] xs + [2] = c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(nil(),n,x,xs) = [1] x + [1] xs + [2] >= [1] xs + [1] = c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) = [4] m1 + [1] m2 + [5] >= [4] m1 + [1] m2 + [5] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [4] l + [4] ls + [1] m2 + [9] >= [1] m2 + [4] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [4] l + [4] ls + [1] m2 + [9] >= [4] ls + [1] m2 + [5] = matrixMult#(ls,m2) ****** Step 7.a:3.b:1.b:1.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ****** Step 7.a:3.b:1.b:1.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) -->_1 computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs):2 2:W:computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc):4 -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)):3 3:W:computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):1 4:W:computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) -->_1 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):5 5:W:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):6 6:W:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())):8 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)):7 7:W:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):5 8:W:lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) -->_1 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):5 9:W:matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) -->_1 matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2):11 -->_1 matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()):10 10:W:matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):1 11:W:matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) -->_1 matrixMult#(m1,m2) -> matrixMult'1#(m1,m2):9 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 9: matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) 11: matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) 10: matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) 1: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) 2: computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) 4: computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) 5: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 8: lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) 6: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 7: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),lineMult#(n,xs,ys)) ****** Step 7.a:3.b:1.b:1.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). ***** Step 7.a:3.b:1.b:1.b:1: NaturalMI MAYBE + Considered Problem: - Strict DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak DPs: add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> add#(mult(x,n),y) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 2, miDegree = 2, 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_3) = {1}, uargs(c_5) = {1}, uargs(c_27) = {1} Following symbols are considered usable: {'mult,mult,'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2# ,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [1] [0] p('add) = [0 0] x1 + [1 0] x2 + [1] [1 0] [0 0] [1] p('mult) = [1] [0] p('natadd) = [0 1] x2 + [0] [0 0] [0] p('natmult) = [0 0] x1 + [0 0] x2 + [0] [1 1] [0 1] [0] p('neg) = [1] [0] p('pos) = [0] [0] p('pred) = [1 0] x1 + [1] [1 0] [0] p('s) = [0] [0] p('succ) = [0 1] x1 + [0] [0 0] [0] p(add) = [0] [0] p(computeLine) = [0] [0] p(computeLine'1) = [0] [0] p(computeLine'2) = [0] [0] p(dd) = [1 0] x1 + [1 1] x2 + [1] [0 1] [0 1] [0] p(lineMult) = [0 0] x1 + [0 0] x2 + [1 0] x3 + [0] [0 1] [0 1] [0 0] [0] p(lineMult'1) = [1] [1] p(lineMult'2) = [1] [1] p(matrixMult) = [0] [0] p(matrixMult'1) = [0] [0] p(mult) = [0 0] x2 + [1] [1 0] [0] p(nil) = [1] [0] p('add#) = [1 0] x1 + [0 0] x2 + [0] [1 0] [1 1] [1] p('mult#) = [0] [0] p('natadd#) = [0] [0] p('natmult#) = [0] [0] p('pred#) = [0] [0] p('succ#) = [0] [0] p(add#) = [1 0] x1 + [0] [1 0] [0] p(computeLine#) = [0 1] x1 + [1 1] x2 + [0] [0 0] [0 0] [1] p(computeLine'1#) = [0 1] x1 + [1 1] x3 + [0] [0 0] [0 0] [1] p(computeLine'2#) = [1 1] x1 + [0 1] x3 + [0 1] x4 + [0] [0 0] [0 0] [0 0] [1] p(lineMult#) = [0 1] x1 + [1 1] x2 + [1] [0 0] [0 0] [1] p(lineMult'1#) = [1 1] x1 + [0 1] x3 + [0] [0 0] [0 0] [1] p(lineMult'2#) = [0 1] x2 + [1 0] x3 + [1 1] x4 + [1] [0 0] [0 0] [0 0] [1] p(matrixMult#) = [0 1] x1 + [1 1] x2 + [0] [0 0] [0 0] [1] p(matrixMult'1#) = [0 1] x1 + [1 1] x2 + [0] [0 0] [0 0] [1] p(mult#) = [0] [0] p(c_1) = [0] [0] p(c_2) = [0] [0] p(c_3) = [1 0] x1 + [0] [0 1] [1] p(c_4) = [0] [0] p(c_5) = [1 0] x1 + [0] [0 1] [0] p(c_6) = [0] [0] p(c_7) = [0] [0] p(c_8) = [0] [0] p(c_9) = [0] [0] p(c_10) = [0] [0] p(c_11) = [0] [0] p(c_12) = [0] [0] p(c_13) = [0] [0] p(c_14) = [0] [0] p(c_15) = [0] [0] p(c_16) = [0] [0] p(c_17) = [0] [0] p(c_18) = [0] [0] p(c_19) = [0] [0] p(c_20) = [0] [0] p(c_21) = [0] [0] p(c_22) = [0] [0] p(c_23) = [0] [0] p(c_24) = [0] [0] p(c_25) = [0] [0] p(c_26) = [0] [0] p(c_27) = [1 0] x1 + [0] [1 0] [0] p(c_28) = [0] [0] p(c_29) = [0] [0] p(c_30) = [0] [0] p(c_31) = [0] [0] p(c_32) = [0] [0] p(c_33) = [0] [0] p(c_34) = [0] [0] p(c_35) = [0] [0] p(c_36) = [0] [0] p(c_37) = [0] [0] p(c_38) = [0] [0] p(c_39) = [0] [0] p(c_40) = [0] [0] p(c_41) = [0] [0] Following rules are strictly oriented: 'add#('neg('s('s(x))),y) = [0 0] y + [1] [1 1] [2] > [0 0] y + [0] [1 1] [2] = c_3('add#('pos('s(x)),y)) Following rules are (at-least) weakly oriented: 'add#('pos('s('s(x))),y) = [0 0] y + [0] [1 1] [1] >= [0 0] y + [0] [1 1] [1] = c_5('add#('pos('s(x)),y)) add#(x,y) = [1 0] x + [0] [1 0] [0] >= [1 0] x + [0] [1 0] [0] = c_27('add#(x,y)) computeLine#(line,m,acc) = [0 1] line + [1 1] m + [0] [0 0] [0 0] [1] >= [0 1] line + [1 1] m + [0] [0 0] [0 0] [1] = computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) = [1 1] m + [0 1] x + [0 1] xs + [0] [0 0] [0 0] [0 0] [1] >= [1 1] m + [0 1] x + [0 1] xs + [0] [0 0] [0 0] [0 0] [1] = computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) = [1 1] l + [1 2] ls + [0 1] x + [0 1] xs + [1] [0 0] [0 0] [0 0] [0 0] [1] >= [1 1] ls + [0 1] xs + [0] [0 0] [0 0] [1] = computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) = [1 1] l + [1 2] ls + [0 1] x + [0 1] xs + [1] [0 0] [0 0] [0 0] [0 0] [1] >= [1 1] l + [0 1] x + [1] [0 0] [0 0] [1] = lineMult#(x,l,acc) lineMult#(n,l1,l2) = [1 1] l1 + [0 1] n + [1] [0 0] [0 0] [1] >= [1 1] l1 + [0 1] n + [0] [0 0] [0 0] [1] = lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) = [0 1] n + [1 1] x + [1 2] xs + [1] [0 0] [0 0] [0 0] [1] >= [0 1] n + [1 0] x + [1 1] xs + [1] [0 0] [0 0] [0 0] [1] = lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) = [0 1] n + [1 0] x + [1 1] xs + [1] [0 0] [0 0] [0 0] [1] >= [1] [1] = add#(mult(x,n),y) lineMult'2#(dd(y,ys),n,x,xs) = [0 1] n + [1 0] x + [1 1] xs + [1] [0 0] [0 0] [0 0] [1] >= [0 1] n + [1 1] xs + [1] [0 0] [0 0] [1] = lineMult#(n,xs,ys) lineMult'2#(nil(),n,x,xs) = [0 1] n + [1 0] x + [1 1] xs + [1] [0 0] [0 0] [0 0] [1] >= [0 1] n + [1 1] xs + [1] [0 0] [0 0] [1] = lineMult#(n,xs,nil()) matrixMult#(m1,m2) = [0 1] m1 + [1 1] m2 + [0] [0 0] [0 0] [1] >= [0 1] m1 + [1 1] m2 + [0] [0 0] [0 0] [1] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [0 1] l + [0 1] ls + [1 1] m2 + [0] [0 0] [0 0] [0 0] [1] >= [0 1] l + [1 1] m2 + [0] [0 0] [0 0] [1] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [0 1] l + [0 1] ls + [1 1] m2 + [0] [0 0] [0 0] [0 0] [1] >= [0 1] ls + [1 1] m2 + [0] [0 0] [0 0] [1] = matrixMult#(ls,m2) 'mult('0(),'0()) = [1] [0] >= [1] [0] = '0() 'mult('0(),'neg(y)) = [1] [0] >= [1] [0] = '0() 'mult('0(),'pos(y)) = [1] [0] >= [1] [0] = '0() 'mult('neg(x),'0()) = [1] [0] >= [1] [0] = '0() 'mult('neg(x),'neg(y)) = [1] [0] >= [0] [0] = 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) = [1] [0] >= [1] [0] = 'neg('natmult(x,y)) 'mult('pos(x),'0()) = [1] [0] >= [1] [0] = '0() 'mult('pos(x),'neg(y)) = [1] [0] >= [1] [0] = 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) = [1] [0] >= [0] [0] = 'pos('natmult(x,y)) mult(x,y) = [0 0] y + [1] [1 0] [0] >= [1] [0] = 'mult(x,y) ***** Step 7.a:3.b:1.b:1.b:2: Failure MAYBE + Considered Problem: - Strict DPs: 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> add#(mult(x,n),y) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is still open. ** Step 7.b:1: PredecessorEstimation WORST_CASE(?,O(n^5)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) add#(x,y) -> c_27('add#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {7} by application of Pre({7}) = {13}. Here rules are labelled as follows: 1: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 2: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 3: 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 4: 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 5: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 6: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 7: add#(x,y) -> c_27('add#(x,y)) 8: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 9: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 10: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 11: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 12: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 13: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) 14: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) 15: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 16: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) 17: mult#(x,y) -> c_41('mult#(x,y)) 18: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 19: 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) ** Step 7.b:2: RemoveWeakSuffixes WORST_CASE(?,O(n^5)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak DPs: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) add#(x,y) -> c_27('add#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 2:S:'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 3:S:'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 4:S:'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 5:S:'natadd#('s(x),y) -> c_16('natadd#(x,y)) -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):5 6:S:'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) -->_2 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):5 7:S:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):8 8:S:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):9 9:S:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):10 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):7 10:S:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):11 11:S:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):13 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)):12 12:S:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) -->_1 add#(x,y) -> c_27('add#(x,y)):19 -->_2 mult#(x,y) -> c_41('mult#(x,y)):16 -->_3 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):10 13:S:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_1 mult#(x,y) -> c_41('mult#(x,y)):16 -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):10 14:S:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):15 15:S:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):14 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):7 16:S:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)):4 -->_1 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)):3 -->_1 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)):2 -->_1 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)):1 17:W:'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):18 18:W:'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):18 19:W:add#(x,y) -> c_27('add#(x,y)) -->_1 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)):18 -->_1 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)):17 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 19: add#(x,y) -> c_27('add#(x,y)) 17: 'add#('neg('s('s(x))),y) -> c_3('add#('pos('s(x)),y)) 18: 'add#('pos('s('s(x))),y) -> c_5('add#('pos('s(x)),y)) ** Step 7.b:3: SimplifyRHS WORST_CASE(?,O(n^5)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/3,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 2:S:'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 3:S:'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 4:S:'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 5:S:'natadd#('s(x),y) -> c_16('natadd#(x,y)) -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):5 6:S:'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) -->_2 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):6 -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):5 7:S:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):8 8:S:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):9 9:S:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):10 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):7 10:S:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):11 11:S:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):13 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)):12 12:S:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(add#(mult(x,n),y),mult#(x,n),lineMult#(n,xs,ys)) -->_2 mult#(x,y) -> c_41('mult#(x,y)):16 -->_3 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):10 13:S:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_1 mult#(x,y) -> c_41('mult#(x,y)):16 -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):10 14:S:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):15 15:S:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):14 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):7 16:S:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)):4 -->_1 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)):3 -->_1 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)):2 -->_1 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)):1 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) ** Step 7.b:4: Decompose WORST_CASE(?,O(n^5)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd} + Details: We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component. Problem (R) - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} Problem (S) - Strict DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} *** Step 7.b:4.a:1: DecomposeDG WORST_CASE(?,O(n^5)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing} + Details: We decompose the input problem according to the dependency graph into the upper component matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) and a lower component 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) mult#(x,y) -> c_41('mult#(x,y)) Further, following extension rules are added to the lower component. matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) **** Step 7.b:4.a:1.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) Consider the set of all dependency pairs 1: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) 2: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1)) SPACE(?,?)on application of the dependency pairs {1} These cover all (indirect) predecessors of dependency pairs {1,2} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. ***** Step 7.b:4.a:1.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_38) = {1}, uargs(c_39) = {2} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [1] p('add) = [0] p('mult) = [1] x1 + [0] p('natadd) = [0] p('natmult) = [0] p('neg) = [3] p('pos) = [0] p('pred) = [0] p('s) = [1] x1 + [0] p('succ) = [1] x1 + [0] p(add) = [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x2 + [6] p(lineMult) = [0] p(lineMult'1) = [1] x1 + [0] p(lineMult'2) = [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [0] p(nil) = [3] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [1] x1 + [0] p(computeLine#) = [0] p(computeLine'1#) = [0] p(computeLine'2#) = [0] p(lineMult#) = [0] p(lineMult'1#) = [0] p(lineMult'2#) = [0] p(matrixMult#) = [2] x1 + [3] p(matrixMult'1#) = [2] x1 + [0] p(mult#) = [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [0] p(c_18) = [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [0] p(c_28) = [0] p(c_29) = [0] p(c_30) = [0] p(c_31) = [0] p(c_32) = [0] p(c_33) = [0] p(c_34) = [0] p(c_35) = [0] p(c_36) = [0] p(c_37) = [0] p(c_38) = [1] x1 + [0] p(c_39) = [1] x2 + [4] p(c_40) = [0] p(c_41) = [0] Following rules are strictly oriented: matrixMult'1#(dd(l,ls),m2) = [2] ls + [12] > [2] ls + [7] = c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) Following rules are (at-least) weakly oriented: matrixMult#(m1,m2) = [2] m1 + [3] >= [2] m1 + [0] = c_38(matrixMult'1#(m1,m2)) ***** Step 7.b:4.a:1.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ***** Step 7.b:4.a:1.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):2 2:W:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 1: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 2: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) ***** Step 7.b:4.a:1.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). **** Step 7.b:4.a:1.b:1: DecomposeDG WORST_CASE(?,O(n^4)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing} + Details: We decompose the input problem according to the dependency graph into the upper component computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) and a lower component 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) mult#(x,y) -> c_41('mult#(x,y)) Further, following extension rules are added to the lower component. computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) ***** Step 7.b:4.a:1.b:1.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) The strictly oriented rules are moved into the weak component. ****** Step 7.b:4.a:1.b:1.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_28) = {1}, uargs(c_29) = {1}, uargs(c_31) = {1} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [0] p('add) = [1] x2 + [1] p('mult) = [1] x2 + [4] p('natadd) = [0] p('natmult) = [0] p('neg) = [1] p('pos) = [1] p('pred) = [1] p('s) = [3] p('succ) = [5] x1 + [4] p(add) = [1] x1 + [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [4] p(lineMult) = [0] p(lineMult'1) = [2] x1 + [0] p(lineMult'2) = [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [0] p(nil) = [0] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [3] x1 + [1] p(computeLine'1#) = [3] x1 + [1] p(computeLine'2#) = [3] x3 + [3] x4 + [2] p(lineMult#) = [0] p(lineMult'1#) = [1] x3 + [0] p(lineMult'2#) = [4] x1 + [1] p(matrixMult#) = [3] x1 + [0] p(matrixMult'1#) = [3] x1 + [0] p(mult#) = [1] x1 + [1] x2 + [0] p(c_1) = [0] p(c_2) = [1] x1 + [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [2] x1 + [2] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [0] p(c_18) = [2] x1 + [2] x2 + [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [4] x1 + [0] p(c_28) = [1] x1 + [0] p(c_29) = [1] x1 + [2] p(c_30) = [0] p(c_31) = [1] x1 + [1] x2 + [0] p(c_32) = [0] p(c_33) = [0] p(c_34) = [2] x1 + [0] p(c_35) = [0] p(c_36) = [2] x2 + [0] p(c_37) = [1] x2 + [0] p(c_38) = [1] x1 + [0] p(c_39) = [1] x1 + [1] x2 + [0] p(c_40) = [0] p(c_41) = [4] x1 + [0] Following rules are strictly oriented: computeLine'2#(dd(l,ls),acc,x,xs) = [3] x + [3] xs + [2] > [3] xs + [1] = c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) Following rules are (at-least) weakly oriented: computeLine#(line,m,acc) = [3] line + [1] >= [3] line + [1] = c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) = [3] x + [3] xs + [13] >= [3] x + [3] xs + [4] = c_29(computeLine'2#(m,acc,x,xs)) matrixMult#(m1,m2) = [3] m1 + [0] >= [3] m1 + [0] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [3] l + [3] ls + [12] >= [3] l + [1] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [3] l + [3] ls + [12] >= [3] ls + [0] = matrixMult#(ls,m2) ****** Step 7.b:4.a:1.b:1.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ****** Step 7.b:4.a:1.b:1.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):2 2:W:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):3 3:W:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 4:W:matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) -->_1 matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2):6 -->_1 matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()):5 5:W:matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 6:W:matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) -->_1 matrixMult#(m1,m2) -> matrixMult'1#(m1,m2):4 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 4: matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) 6: matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) 5: matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) 1: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 2: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) ****** Step 7.b:4.a:1.b:1.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). ***** Step 7.b:4.a:1.b:1.b:1: DecomposeDG WORST_CASE(?,O(n^3)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing} + Details: We decompose the input problem according to the dependency graph into the upper component computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) and a lower component 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) mult#(x,y) -> c_41('mult#(x,y)) Further, following extension rules are added to the lower component. computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) ****** Step 7.b:4.a:1.b:1.b:1.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) The strictly oriented rules are moved into the weak component. ******* Step 7.b:4.a:1.b:1.b:1.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_33) = {1}, uargs(c_34) = {1}, uargs(c_36) = {2}, uargs(c_37) = {2} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [0] p('add) = [2] p('mult) = [7] x1 + [4] p('natadd) = [3] x2 + [0] p('natmult) = [3] x1 + [4] x2 + [1] p('neg) = [1] p('pos) = [0] p('pred) = [4] x1 + [5] p('s) = [1] p('succ) = [7] x1 + [1] p(add) = [1] x1 + [6] x2 + [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [1] p(lineMult) = [7] x1 + [0] p(lineMult'1) = [2] p(lineMult'2) = [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [1] x1 + [1] x2 + [0] p(nil) = [0] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [1] x1 + [4] x2 + [0] p('pred#) = [4] p('succ#) = [1] x1 + [2] p(add#) = [2] p(computeLine#) = [4] x2 + [0] p(computeLine'1#) = [4] x3 + [0] p(computeLine'2#) = [4] x1 + [0] p(lineMult#) = [4] x2 + [0] p(lineMult'1#) = [4] x1 + [0] p(lineMult'2#) = [4] x4 + [4] p(matrixMult#) = [4] x2 + [1] p(matrixMult'1#) = [4] x2 + [1] p(mult#) = [4] x1 + [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [1] p(c_18) = [0] p(c_19) = [1] p(c_20) = [0] p(c_21) = [4] p(c_22) = [0] p(c_23) = [0] p(c_24) = [2] p(c_25) = [2] p(c_26) = [0] p(c_27) = [0] p(c_28) = [4] x1 + [1] p(c_29) = [1] x1 + [0] p(c_30) = [0] p(c_31) = [1] x2 + [0] p(c_32) = [2] p(c_33) = [1] x1 + [0] p(c_34) = [1] x1 + [0] p(c_35) = [1] p(c_36) = [1] x2 + [0] p(c_37) = [1] x2 + [4] p(c_38) = [1] x1 + [2] p(c_39) = [1] x2 + [0] p(c_40) = [0] p(c_41) = [1] x1 + [1] Following rules are strictly oriented: lineMult'2#(dd(y,ys),n,x,xs) = [4] xs + [4] > [4] xs + [0] = c_36(mult#(x,n),lineMult#(n,xs,ys)) Following rules are (at-least) weakly oriented: computeLine#(line,m,acc) = [4] m + [0] >= [4] m + [0] = computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) = [4] m + [0] >= [4] m + [0] = computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) = [4] l + [4] ls + [4] >= [4] ls + [0] = computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) = [4] l + [4] ls + [4] >= [4] l + [0] = lineMult#(x,l,acc) lineMult#(n,l1,l2) = [4] l1 + [0] >= [4] l1 + [0] = c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) = [4] x + [4] xs + [4] >= [4] xs + [4] = c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(nil(),n,x,xs) = [4] xs + [4] >= [4] xs + [4] = c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) = [4] m2 + [1] >= [4] m2 + [1] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [4] m2 + [1] >= [4] m2 + [0] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [4] m2 + [1] >= [4] m2 + [1] = matrixMult#(ls,m2) ******* Step 7.b:4.a:1.b:1.b:1.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ******* Step 7.b:4.a:1.b:1.b:1.a:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) The strictly oriented rules are moved into the weak component. ******** Step 7.b:4.a:1.b:1.b:1.a:1.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_33) = {1}, uargs(c_34) = {1}, uargs(c_36) = {2}, uargs(c_37) = {2} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [3] p('add) = [0] p('mult) = [1] x1 + [4] x2 + [0] p('natadd) = [1] x1 + [2] x2 + [0] p('natmult) = [2] x1 + [4] p('neg) = [1] x1 + [3] p('pos) = [0] p('pred) = [0] p('s) = [4] p('succ) = [3] p(add) = [2] x1 + [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [5] p(lineMult) = [2] x1 + [4] x2 + [0] p(lineMult'1) = [1] x1 + [0] p(lineMult'2) = [7] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [4] x2 + [4] p(nil) = [0] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [2] x2 + [0] p(computeLine'1#) = [2] x3 + [0] p(computeLine'2#) = [2] x1 + [0] p(lineMult#) = [1] x2 + [0] p(lineMult'1#) = [1] x1 + [0] p(lineMult'2#) = [1] x3 + [1] x4 + [1] p(matrixMult#) = [2] x2 + [2] p(matrixMult'1#) = [2] x2 + [2] p(mult#) = [1] x1 + [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [0] p(c_18) = [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [0] p(c_28) = [0] p(c_29) = [0] p(c_30) = [0] p(c_31) = [0] p(c_32) = [0] p(c_33) = [1] x1 + [0] p(c_34) = [1] x1 + [4] p(c_35) = [2] p(c_36) = [1] x2 + [1] p(c_37) = [1] x2 + [0] p(c_38) = [0] p(c_39) = [0] p(c_40) = [0] p(c_41) = [0] Following rules are strictly oriented: lineMult'2#(nil(),n,x,xs) = [1] x + [1] xs + [1] > [1] xs + [0] = c_37(mult#(x,n),lineMult#(n,xs,nil())) Following rules are (at-least) weakly oriented: computeLine#(line,m,acc) = [2] m + [0] >= [2] m + [0] = computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) = [2] m + [0] >= [2] m + [0] = computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) = [2] l + [2] ls + [10] >= [2] ls + [0] = computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) = [2] l + [2] ls + [10] >= [1] l + [0] = lineMult#(x,l,acc) lineMult#(n,l1,l2) = [1] l1 + [0] >= [1] l1 + [0] = c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) = [1] x + [1] xs + [5] >= [1] x + [1] xs + [5] = c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) = [1] x + [1] xs + [1] >= [1] xs + [1] = c_36(mult#(x,n),lineMult#(n,xs,ys)) matrixMult#(m1,m2) = [2] m2 + [2] >= [2] m2 + [2] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [2] m2 + [2] >= [2] m2 + [0] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [2] m2 + [2] >= [2] m2 + [2] = matrixMult#(ls,m2) ******** Step 7.b:4.a:1.b:1.b:1.a:1.b:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ******** Step 7.b:4.a:1.b:1.b:1.a:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) -->_1 computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs):2 2:W:computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc):4 -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)):3 3:W:computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):1 4:W:computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) -->_1 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):5 5:W:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):6 6:W:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):8 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)):7 7:W:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):5 8:W:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):5 9:W:matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) -->_1 matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2):11 -->_1 matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()):10 10:W:matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):1 11:W:matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) -->_1 matrixMult#(m1,m2) -> matrixMult'1#(m1,m2):9 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 9: matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) 11: matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) 10: matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) 1: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) 2: computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) 4: computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) 5: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 8: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) 6: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 7: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) ******** Step 7.b:4.a:1.b:1.b:1.a:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). ****** Step 7.b:4.a:1.b:1.b:1.b:1: DecomposeDG WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing} + Details: We decompose the input problem according to the dependency graph into the upper component 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) and a lower component 'natadd#('s(x),y) -> c_16('natadd#(x,y)) Further, following extension rules are added to the lower component. 'mult#('neg(x),'neg(y)) -> 'natmult#(x,y) 'mult#('neg(x),'pos(y)) -> 'natmult#(x,y) 'mult#('pos(x),'neg(y)) -> 'natmult#(x,y) 'mult#('pos(x),'pos(y)) -> 'natmult#(x,y) 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)) 'natmult#('s(x),y) -> 'natmult#(x,y) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> 'mult#(x,y) ******* Step 7.b:4.a:1.b:1.b:1.b:1.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 2: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) The strictly oriented rules are moved into the weak component. ******** Step 7.b:4.a:1.b:1.b:1.b:1.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_10) = {1}, uargs(c_11) = {1}, uargs(c_13) = {1}, uargs(c_14) = {1}, uargs(c_18) = {1,2}, uargs(c_41) = {1} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [1] p('add) = [1] x1 + [0] p('mult) = [5] p('natadd) = [2] x1 + [7] p('natmult) = [0] p('neg) = [1] x1 + [0] p('pos) = [1] x1 + [0] p('pred) = [0] p('s) = [1] x1 + [4] p('succ) = [1] x1 + [3] p(add) = [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [0] p(lineMult) = [0] p(lineMult'1) = [0] p(lineMult'2) = [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [0] p(nil) = [4] p('add#) = [0] p('mult#) = [4] x1 + [7] p('natadd#) = [0] p('natmult#) = [2] x1 + [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [7] x2 + [7] p(computeLine'1#) = [7] x3 + [7] p(computeLine'2#) = [7] x1 + [7] p(lineMult#) = [7] x2 + [7] p(lineMult'1#) = [7] x1 + [7] p(lineMult'2#) = [6] x3 + [7] x4 + [7] p(matrixMult#) = [2] x1 + [7] x2 + [7] p(matrixMult'1#) = [2] x1 + [7] x2 + [7] p(mult#) = [6] x1 + [7] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [1] p(c_10) = [1] x1 + [7] p(c_11) = [1] x1 + [7] p(c_12) = [0] p(c_13) = [2] x1 + [7] p(c_14) = [2] x1 + [7] p(c_15) = [0] p(c_16) = [0] p(c_17) = [2] p(c_18) = [1] x1 + [1] x2 + [5] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [0] p(c_28) = [0] p(c_29) = [0] p(c_30) = [0] p(c_31) = [0] p(c_32) = [0] p(c_33) = [0] p(c_34) = [0] 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] x1 + [0] Following rules are strictly oriented: 'natmult#('s(x),y) = [2] x + [8] > [2] x + [5] = c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) Following rules are (at-least) weakly oriented: 'mult#('neg(x),'neg(y)) = [4] x + [7] >= [2] x + [7] = c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) = [4] x + [7] >= [2] x + [7] = c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) = [4] x + [7] >= [4] x + [7] = c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) = [4] x + [7] >= [4] x + [7] = c_14('natmult#(x,y)) computeLine#(line,m,acc) = [7] m + [7] >= [7] m + [7] = computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) = [7] m + [7] >= [7] m + [7] = computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) = [7] l + [7] ls + [7] >= [7] ls + [7] = computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) = [7] l + [7] ls + [7] >= [7] l + [7] = lineMult#(x,l,acc) lineMult#(n,l1,l2) = [7] l1 + [7] >= [7] l1 + [7] = lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) = [7] x + [7] xs + [7] >= [6] x + [7] xs + [7] = lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) = [6] x + [7] xs + [7] >= [7] xs + [7] = lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) = [6] x + [7] xs + [7] >= [6] x + [7] = mult#(x,n) lineMult'2#(nil(),n,x,xs) = [6] x + [7] xs + [7] >= [7] xs + [7] = lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) = [6] x + [7] xs + [7] >= [6] x + [7] = mult#(x,n) matrixMult#(m1,m2) = [2] m1 + [7] m2 + [7] >= [2] m1 + [7] m2 + [7] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [2] l + [2] ls + [7] m2 + [7] >= [7] m2 + [7] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [2] l + [2] ls + [7] m2 + [7] >= [2] ls + [7] m2 + [7] = matrixMult#(ls,m2) mult#(x,y) = [6] x + [7] >= [4] x + [7] = c_41('mult#(x,y)) ******** Step 7.b:4.a:1.b:1.b:1.b:1.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ******** Step 7.b:4.a:1.b:1.b:1.b:1.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) - Weak DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):5 2:W:'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):5 3:W:'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):5 4:W:'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):5 5:W:'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) -->_2 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):5 6:W:computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) -->_1 computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs):7 7:W:computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc):9 -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)):8 8:W:computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):6 9:W:computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):10 10:W:lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) -->_1 lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs):11 11:W:lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) -->_1 lineMult'2#(nil(),n,x,xs) -> mult#(x,n):15 -->_1 lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()):14 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n):13 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys):12 12:W:lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):10 13:W:lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) -->_1 mult#(x,y) -> c_41('mult#(x,y)):19 14:W:lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):10 15:W:lineMult'2#(nil(),n,x,xs) -> mult#(x,n) -->_1 mult#(x,y) -> c_41('mult#(x,y)):19 16:W:matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) -->_1 matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2):18 -->_1 matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()):17 17:W:matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):6 18:W:matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) -->_1 matrixMult#(m1,m2) -> matrixMult'1#(m1,m2):16 19:W:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)):4 -->_1 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)):3 -->_1 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)):2 -->_1 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 4: 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 3: 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 2: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 5: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) ******** Step 7.b:4.a:1.b:1.b:1.b:1.a:1.b:2: SimplifyRHS WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 6:W:computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) -->_1 computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs):7 7:W:computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc):9 -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)):8 8:W:computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):6 9:W:computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):10 10:W:lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) -->_1 lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs):11 11:W:lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) -->_1 lineMult'2#(nil(),n,x,xs) -> mult#(x,n):15 -->_1 lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()):14 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n):13 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys):12 12:W:lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):10 13:W:lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) -->_1 mult#(x,y) -> c_41('mult#(x,y)):19 14:W:lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):10 15:W:lineMult'2#(nil(),n,x,xs) -> mult#(x,n) -->_1 mult#(x,y) -> c_41('mult#(x,y)):19 16:W:matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) -->_1 matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2):18 -->_1 matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()):17 17:W:matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):6 18:W:matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) -->_1 matrixMult#(m1,m2) -> matrixMult'1#(m1,m2):16 19:W:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)):1 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: 'mult#('neg(x),'neg(y)) -> c_10() ******** Step 7.b:4.a:1.b:1.b:1.b:1.a:1.b:3: PredecessorEstimationCP WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10() - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: 'mult#('neg(x),'neg(y)) -> c_10() The strictly oriented rules are moved into the weak component. ********* Step 7.b:4.a:1.b:1.b:1.b:1.a:1.b:3.a:1: NaturalMI WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'neg(y)) -> c_10() - Weak DPs: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_41) = {1} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [2] p('add) = [1] x1 + [5] p('mult) = [2] x1 + [1] x2 + [5] p('natadd) = [4] x1 + [5] x2 + [0] p('natmult) = [1] x2 + [0] p('neg) = [0] p('pos) = [2] p('pred) = [4] p('s) = [0] p('succ) = [2] x1 + [0] p(add) = [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [3] p(lineMult) = [0] p(lineMult'1) = [2] x1 + [0] p(lineMult'2) = [1] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [0] p(nil) = [0] p('add#) = [0] p('mult#) = [4] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [6] p(computeLine'1#) = [6] p(computeLine'2#) = [6] p(lineMult#) = [4] p(lineMult'1#) = [4] p(lineMult'2#) = [4] p(matrixMult#) = [6] p(matrixMult'1#) = [6] p(mult#) = [4] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [0] p(c_18) = [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [0] p(c_28) = [1] x1 + [0] p(c_29) = [0] p(c_30) = [0] p(c_31) = [0] p(c_32) = [0] p(c_33) = [0] p(c_34) = [0] p(c_35) = [0] p(c_36) = [0] p(c_37) = [1] x1 + [0] p(c_38) = [0] p(c_39) = [0] p(c_40) = [0] p(c_41) = [1] x1 + [0] Following rules are strictly oriented: 'mult#('neg(x),'neg(y)) = [4] > [0] = c_10() Following rules are (at-least) weakly oriented: computeLine#(line,m,acc) = [6] >= [6] = computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) = [6] >= [6] = computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) = [6] >= [6] = computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) = [6] >= [4] = lineMult#(x,l,acc) lineMult#(n,l1,l2) = [4] >= [4] = lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) = [4] >= [4] = lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) = [4] >= [4] = lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) = [4] >= [4] = mult#(x,n) lineMult'2#(nil(),n,x,xs) = [4] >= [4] = lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) = [4] >= [4] = mult#(x,n) matrixMult#(m1,m2) = [6] >= [6] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [6] >= [6] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [6] >= [6] = matrixMult#(ls,m2) mult#(x,y) = [4] >= [4] = c_41('mult#(x,y)) ********* Step 7.b:4.a:1.b:1.b:1.b:1.a:1.b:3.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: 'mult#('neg(x),'neg(y)) -> c_10() computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ********* Step 7.b:4.a:1.b:1.b:1.b:1.a:1.b:3.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: 'mult#('neg(x),'neg(y)) -> c_10() computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:'mult#('neg(x),'neg(y)) -> c_10() 2:W:computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) -->_1 computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs):3 3:W:computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc):5 -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)):4 4:W:computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):2 5:W:computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):6 6:W:lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) -->_1 lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs):7 7:W:lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) -->_1 lineMult'2#(nil(),n,x,xs) -> mult#(x,n):11 -->_1 lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()):10 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n):9 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys):8 8:W:lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):6 9:W:lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) -->_1 mult#(x,y) -> c_41('mult#(x,y)):15 10:W:lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):6 11:W:lineMult'2#(nil(),n,x,xs) -> mult#(x,n) -->_1 mult#(x,y) -> c_41('mult#(x,y)):15 12:W:matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) -->_1 matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2):14 -->_1 matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()):13 13:W:matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):2 14:W:matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) -->_1 matrixMult#(m1,m2) -> matrixMult'1#(m1,m2):12 15:W:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('neg(x),'neg(y)) -> c_10():1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 12: matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) 14: matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) 13: matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) 2: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) 4: computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) 3: computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) 5: computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) 6: lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) 10: lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) 7: lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) 8: lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) 9: lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) 11: lineMult'2#(nil(),n,x,xs) -> mult#(x,n) 15: mult#(x,y) -> c_41('mult#(x,y)) 1: 'mult#('neg(x),'neg(y)) -> c_10() ********* Step 7.b:4.a:1.b:1.b:1.b:1.a:1.b:3.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/0,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). ******* Step 7.b:4.a:1.b:1.b:1.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) - Weak DPs: 'mult#('neg(x),'neg(y)) -> 'natmult#(x,y) 'mult#('neg(x),'pos(y)) -> 'natmult#(x,y) 'mult#('pos(x),'neg(y)) -> 'natmult#(x,y) 'mult#('pos(x),'pos(y)) -> 'natmult#(x,y) 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)) 'natmult#('s(x),y) -> 'natmult#(x,y) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> 'mult#(x,y) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) The strictly oriented rules are moved into the weak component. ******** Step 7.b:4.a:1.b:1.b:1.b:1.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) - Weak DPs: 'mult#('neg(x),'neg(y)) -> 'natmult#(x,y) 'mult#('neg(x),'pos(y)) -> 'natmult#(x,y) 'mult#('pos(x),'neg(y)) -> 'natmult#(x,y) 'mult#('pos(x),'pos(y)) -> 'natmult#(x,y) 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)) 'natmult#('s(x),y) -> 'natmult#(x,y) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> 'mult#(x,y) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_16) = {1} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [3] p('add) = [3] p('mult) = [4] x1 + [3] p('natadd) = [2] x1 + [5] p('natmult) = [0] p('neg) = [1] x1 + [0] p('pos) = [1] x1 + [1] p('pred) = [5] p('s) = [1] x1 + [4] p('succ) = [0] p(add) = [4] x1 + [7] p(computeLine) = [0] p(computeLine'1) = [1] x3 + [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [1] p(lineMult) = [3] x1 + [1] x2 + [2] x3 + [7] p(lineMult'1) = [1] x1 + [3] p(lineMult'2) = [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [1] x2 + [0] p(nil) = [1] p('add#) = [0] p('mult#) = [2] x2 + [2] p('natadd#) = [2] x1 + [0] p('natmult#) = [2] x2 + [2] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [2] x1 + [0] p(computeLine'1#) = [2] x1 + [0] p(computeLine'2#) = [2] x3 + [2] x4 + [2] p(lineMult#) = [2] x1 + [2] p(lineMult'1#) = [2] x3 + [2] p(lineMult'2#) = [2] x2 + [2] p(matrixMult#) = [2] x1 + [0] p(matrixMult'1#) = [2] x1 + [0] p(mult#) = [2] x2 + [2] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [1] x1 + [4] p(c_17) = [0] p(c_18) = [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [0] p(c_28) = [0] p(c_29) = [0] p(c_30) = [0] p(c_31) = [0] p(c_32) = [0] p(c_33) = [0] p(c_34) = [0] 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) = [0] Following rules are strictly oriented: 'natadd#('s(x),y) = [2] x + [8] > [2] x + [4] = c_16('natadd#(x,y)) Following rules are (at-least) weakly oriented: 'mult#('neg(x),'neg(y)) = [2] y + [2] >= [2] y + [2] = 'natmult#(x,y) 'mult#('neg(x),'pos(y)) = [2] y + [4] >= [2] y + [2] = 'natmult#(x,y) 'mult#('pos(x),'neg(y)) = [2] y + [2] >= [2] y + [2] = 'natmult#(x,y) 'mult#('pos(x),'pos(y)) = [2] y + [4] >= [2] y + [2] = 'natmult#(x,y) 'natmult#('s(x),y) = [2] y + [2] >= [2] y + [0] = 'natadd#(y,'natmult(x,y)) 'natmult#('s(x),y) = [2] y + [2] >= [2] y + [2] = 'natmult#(x,y) computeLine#(line,m,acc) = [2] line + [0] >= [2] line + [0] = computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) = [2] x + [2] xs + [2] >= [2] x + [2] xs + [2] = computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) = [2] x + [2] xs + [2] >= [2] xs + [0] = computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) = [2] x + [2] xs + [2] >= [2] x + [2] = lineMult#(x,l,acc) lineMult#(n,l1,l2) = [2] n + [2] >= [2] n + [2] = lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) = [2] n + [2] >= [2] n + [2] = lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) = [2] n + [2] >= [2] n + [2] = lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) = [2] n + [2] >= [2] n + [2] = mult#(x,n) lineMult'2#(nil(),n,x,xs) = [2] n + [2] >= [2] n + [2] = lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) = [2] n + [2] >= [2] n + [2] = mult#(x,n) matrixMult#(m1,m2) = [2] m1 + [0] >= [2] m1 + [0] = matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) = [2] l + [2] ls + [2] >= [2] l + [0] = computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) = [2] l + [2] ls + [2] >= [2] ls + [0] = matrixMult#(ls,m2) mult#(x,y) = [2] y + [2] >= [2] y + [2] = 'mult#(x,y) ******** Step 7.b:4.a:1.b:1.b:1.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: 'mult#('neg(x),'neg(y)) -> 'natmult#(x,y) 'mult#('neg(x),'pos(y)) -> 'natmult#(x,y) 'mult#('pos(x),'neg(y)) -> 'natmult#(x,y) 'mult#('pos(x),'pos(y)) -> 'natmult#(x,y) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)) 'natmult#('s(x),y) -> 'natmult#(x,y) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> 'mult#(x,y) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ******** Step 7.b:4.a:1.b:1.b:1.b:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: 'mult#('neg(x),'neg(y)) -> 'natmult#(x,y) 'mult#('neg(x),'pos(y)) -> 'natmult#(x,y) 'mult#('pos(x),'neg(y)) -> 'natmult#(x,y) 'mult#('pos(x),'pos(y)) -> 'natmult#(x,y) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)) 'natmult#('s(x),y) -> 'natmult#(x,y) computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) lineMult'2#(nil(),n,x,xs) -> mult#(x,n) matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) mult#(x,y) -> 'mult#(x,y) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:'mult#('neg(x),'neg(y)) -> 'natmult#(x,y) -->_1 'natmult#('s(x),y) -> 'natmult#(x,y):7 -->_1 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)):6 2:W:'mult#('neg(x),'pos(y)) -> 'natmult#(x,y) -->_1 'natmult#('s(x),y) -> 'natmult#(x,y):7 -->_1 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)):6 3:W:'mult#('pos(x),'neg(y)) -> 'natmult#(x,y) -->_1 'natmult#('s(x),y) -> 'natmult#(x,y):7 -->_1 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)):6 4:W:'mult#('pos(x),'pos(y)) -> 'natmult#(x,y) -->_1 'natmult#('s(x),y) -> 'natmult#(x,y):7 -->_1 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)):6 5:W:'natadd#('s(x),y) -> c_16('natadd#(x,y)) -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):5 6:W:'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)) -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):5 7:W:'natmult#('s(x),y) -> 'natmult#(x,y) -->_1 'natmult#('s(x),y) -> 'natmult#(x,y):7 -->_1 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)):6 8:W:computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) -->_1 computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs):9 9:W:computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc):11 -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)):10 10:W:computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):8 11:W:computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):12 12:W:lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) -->_1 lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs):13 13:W:lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) -->_1 lineMult'2#(nil(),n,x,xs) -> mult#(x,n):17 -->_1 lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()):16 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n):15 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys):14 14:W:lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):12 15:W:lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) -->_1 mult#(x,y) -> 'mult#(x,y):21 16:W:lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) -->_1 lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n):12 17:W:lineMult'2#(nil(),n,x,xs) -> mult#(x,n) -->_1 mult#(x,y) -> 'mult#(x,y):21 18:W:matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) -->_1 matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2):20 -->_1 matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()):19 19:W:matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) -->_1 computeLine#(line,m,acc) -> computeLine'1#(line,acc,m):8 20:W:matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) -->_1 matrixMult#(m1,m2) -> matrixMult'1#(m1,m2):18 21:W:mult#(x,y) -> 'mult#(x,y) -->_1 'mult#('pos(x),'pos(y)) -> 'natmult#(x,y):4 -->_1 'mult#('pos(x),'neg(y)) -> 'natmult#(x,y):3 -->_1 'mult#('neg(x),'pos(y)) -> 'natmult#(x,y):2 -->_1 'mult#('neg(x),'neg(y)) -> 'natmult#(x,y):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 18: matrixMult#(m1,m2) -> matrixMult'1#(m1,m2) 20: matrixMult'1#(dd(l,ls),m2) -> matrixMult#(ls,m2) 19: matrixMult'1#(dd(l,ls),m2) -> computeLine#(l,m2,nil()) 8: computeLine#(line,m,acc) -> computeLine'1#(line,acc,m) 10: computeLine'2#(dd(l,ls),acc,x,xs) -> computeLine#(xs,ls,lineMult(x,l,acc)) 9: computeLine'1#(dd(x,xs),acc,m) -> computeLine'2#(m,acc,x,xs) 11: computeLine'2#(dd(l,ls),acc,x,xs) -> lineMult#(x,l,acc) 12: lineMult#(n,l1,l2) -> lineMult'1#(l1,l2,n) 16: lineMult'2#(nil(),n,x,xs) -> lineMult#(n,xs,nil()) 13: lineMult'1#(dd(x,xs),l2,n) -> lineMult'2#(l2,n,x,xs) 14: lineMult'2#(dd(y,ys),n,x,xs) -> lineMult#(n,xs,ys) 15: lineMult'2#(dd(y,ys),n,x,xs) -> mult#(x,n) 17: lineMult'2#(nil(),n,x,xs) -> mult#(x,n) 21: mult#(x,y) -> 'mult#(x,y) 4: 'mult#('pos(x),'pos(y)) -> 'natmult#(x,y) 3: 'mult#('pos(x),'neg(y)) -> 'natmult#(x,y) 2: 'mult#('neg(x),'pos(y)) -> 'natmult#(x,y) 1: 'mult#('neg(x),'neg(y)) -> 'natmult#(x,y) 7: 'natmult#('s(x),y) -> 'natmult#(x,y) 6: 'natmult#('s(x),y) -> 'natadd#(y,'natmult(x,y)) 5: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) ******** Step 7.b:4.a:1.b:1.b:1.b:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). *** Step 7.b:4.b:1: PredecessorEstimation WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {1,2,3} by application of Pre({1,2,3}) = {13}. Here rules are labelled as follows: 1: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 2: 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 3: 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 4: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 5: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 6: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 7: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 8: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 9: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) 10: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) 11: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 12: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) 13: mult#(x,y) -> c_41('mult#(x,y)) 14: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 15: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 16: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) *** Step 7.b:4.b:2: PredecessorEstimation WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) mult#(x,y) -> c_41('mult#(x,y)) - Weak DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimation {onSelection = all simple predecessor estimation selector} + Details: We estimate the number of application of {10} by application of Pre({10}) = {6,7}. Here rules are labelled as follows: 1: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 2: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 4: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 5: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 6: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) 7: lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) 8: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 9: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) 10: mult#(x,y) -> c_41('mult#(x,y)) 11: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 12: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 13: 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 14: 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 15: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 16: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) *** Step 7.b:4.b:3: RemoveWeakSuffixes WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak DPs: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 'natadd#('s(x),y) -> c_16('natadd#(x,y)) 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) mult#(x,y) -> c_41('mult#(x,y)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):2 2:S:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):3 3:S:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 4:S:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):5 5:S:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):7 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)):6 6:S:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) -->_1 mult#(x,y) -> c_41('mult#(x,y)):16 -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 7:S:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_1 mult#(x,y) -> c_41('mult#(x,y)):16 -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 8:S:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):9 9:S:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):8 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 10:W:'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):15 11:W:'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):15 12:W:'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):15 13:W:'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) -->_1 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):15 14:W:'natadd#('s(x),y) -> c_16('natadd#(x,y)) -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):14 15:W:'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) -->_2 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)):15 -->_1 'natadd#('s(x),y) -> c_16('natadd#(x,y)):14 16:W:mult#(x,y) -> c_41('mult#(x,y)) -->_1 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)):13 -->_1 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)):12 -->_1 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)):11 -->_1 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)):10 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 16: mult#(x,y) -> c_41('mult#(x,y)) 10: 'mult#('neg(x),'neg(y)) -> c_10('natmult#(x,y)) 11: 'mult#('neg(x),'pos(y)) -> c_11('natmult#(x,y)) 12: 'mult#('pos(x),'neg(y)) -> c_13('natmult#(x,y)) 13: 'mult#('pos(x),'pos(y)) -> c_14('natmult#(x,y)) 15: 'natmult#('s(x),y) -> c_18('natadd#(y,'natmult(x,y)),'natmult#(x,y)) 14: 'natadd#('s(x),y) -> c_16('natadd#(x,y)) *** Step 7.b:4.b:4: SimplifyRHS WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/2,c_37/2,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):2 2:S:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):3 3:S:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 4:S:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):5 5:S:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())):7 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)):6 6:S:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(mult#(x,n),lineMult#(n,xs,ys)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 7:S:lineMult'2#(nil(),n,x,xs) -> c_37(mult#(x,n),lineMult#(n,xs,nil())) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 8:S:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):9 9:S:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):8 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) *** Step 7.b:4.b:5: Decompose WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd} + Details: We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component. Problem (R) - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} Problem (S) - Strict DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} **** Step 7.b:4.b:5.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 3: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 5: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) Consider the set of all dependency pairs 1: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 2: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 4: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 5: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 6: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) 7: lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) 8: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 9: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) Processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^2)) SPACE(?,?)on application of the dependency pairs {3,5} These cover all (indirect) predecessors of dependency pairs {3,4,5,6,7} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. ***** Step 7.b:4.b:5.a:1.a:1: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(c_28) = {1}, uargs(c_29) = {1}, uargs(c_31) = {1,2}, uargs(c_33) = {1}, uargs(c_34) = {1}, uargs(c_36) = {1}, uargs(c_37) = {1}, uargs(c_38) = {1}, uargs(c_39) = {1,2} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = 0 p('add) = x1^2 p('mult) = x1^2 p('natadd) = x1^2 p('natmult) = 0 p('neg) = 0 p('pos) = 1 p('pred) = x1 + x1^2 p('s) = 0 p('succ) = 0 p(add) = x1^2 + x2^2 p(computeLine) = 0 p(computeLine'1) = 0 p(computeLine'2) = 0 p(dd) = 1 + x1 + x2 p(lineMult) = 0 p(lineMult'1) = x1 + x1^2 p(lineMult'2) = x2*x3 p(matrixMult) = 0 p(matrixMult'1) = 0 p(mult) = 0 p(nil) = 0 p('add#) = 0 p('mult#) = 0 p('natadd#) = 0 p('natmult#) = 0 p('pred#) = 0 p('succ#) = 0 p(add#) = 0 p(computeLine#) = 1 + x1^2 + x2 p(computeLine'1#) = x1^2 + x3 p(computeLine'2#) = 1 + x1 + x3 + x3^2 + x4^2 p(lineMult#) = x1^2 + x2 p(lineMult'1#) = x1 + x3^2 p(lineMult'2#) = x2^2 + x4 p(matrixMult#) = x1*x2 + x1^2 p(matrixMult'1#) = x1*x2 + x1^2 p(mult#) = 0 p(c_1) = 0 p(c_2) = 0 p(c_3) = 0 p(c_4) = 0 p(c_5) = 0 p(c_6) = 0 p(c_7) = 0 p(c_8) = 0 p(c_9) = 0 p(c_10) = 0 p(c_11) = 0 p(c_12) = 0 p(c_13) = 0 p(c_14) = 0 p(c_15) = 0 p(c_16) = 0 p(c_17) = 0 p(c_18) = 0 p(c_19) = 0 p(c_20) = 0 p(c_21) = 0 p(c_22) = 0 p(c_23) = 0 p(c_24) = 0 p(c_25) = 0 p(c_26) = 0 p(c_27) = 0 p(c_28) = 1 + x1 p(c_29) = x1 p(c_30) = 0 p(c_31) = x1 + x2 p(c_32) = 0 p(c_33) = x1 p(c_34) = x1 p(c_35) = 0 p(c_36) = x1 p(c_37) = x1 p(c_38) = x1 p(c_39) = x1 + x2 p(c_40) = 0 p(c_41) = 0 Following rules are strictly oriented: computeLine'2#(dd(l,ls),acc,x,xs) = 2 + l + ls + x + x^2 + xs^2 > 1 + l + ls + x^2 + xs^2 = c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult'1#(dd(x,xs),l2,n) = 1 + n^2 + x + xs > n^2 + xs = c_34(lineMult'2#(l2,n,x,xs)) Following rules are (at-least) weakly oriented: computeLine#(line,m,acc) = 1 + line^2 + m >= 1 + line^2 + m = c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) = 1 + m + 2*x + 2*x*xs + x^2 + 2*xs + xs^2 >= 1 + m + x + x^2 + xs^2 = c_29(computeLine'2#(m,acc,x,xs)) lineMult#(n,l1,l2) = l1 + n^2 >= l1 + n^2 = c_33(lineMult'1#(l1,l2,n)) lineMult'2#(dd(y,ys),n,x,xs) = n^2 + xs >= n^2 + xs = c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) = n^2 + xs >= n^2 + xs = c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) = m1*m2 + m1^2 >= m1*m2 + m1^2 = c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) = 1 + 2*l + 2*l*ls + l*m2 + l^2 + 2*ls + ls*m2 + ls^2 + m2 >= 1 + l^2 + ls*m2 + ls^2 + m2 = c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) ***** Step 7.b:4.b:5.a:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) - Weak DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ***** Step 7.b:4.b:5.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) - Weak DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):2 2:S:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):3 3:W:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 4:W:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):5 5:W:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())):7 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)):6 6:W:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) -->_1 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 7:W:lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) -->_1 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):4 8:W:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):9 9:W:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):8 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 4: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 7: lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) 5: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 6: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) ***** Step 7.b:4.b:5.a:1.b:2: SimplifyRHS WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) - Weak DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):2 2:S:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):3 3:W:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 8:W:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):9 9:W:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):8 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) ***** Step 7.b:4.b:5.a:1.b:3: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) - Weak DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/1 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 2: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) Consider the set of all dependency pairs 1: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 2: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) 4: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 5: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1)) SPACE(?,?)on application of the dependency pairs {2} These cover all (indirect) predecessors of dependency pairs {2,3} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. ****** Step 7.b:4.b:5.a:1.b:3.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) - Weak DPs: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/1 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_28) = {1}, uargs(c_29) = {1}, uargs(c_31) = {1}, uargs(c_38) = {1}, uargs(c_39) = {1,2} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [2] p('add) = [0] p('mult) = [0] p('natadd) = [4] x1 + [0] p('natmult) = [0] p('neg) = [1] x1 + [0] p('pos) = [1] x1 + [0] p('pred) = [0] p('s) = [1] p('succ) = [0] p(add) = [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [1] p(lineMult) = [0] p(lineMult'1) = [4] x1 + [0] p(lineMult'2) = [4] x1 + [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [0] p(nil) = [3] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [4] x1 + [0] p(computeLine'1#) = [4] x1 + [0] p(computeLine'2#) = [4] x3 + [4] x4 + [0] p(lineMult#) = [0] p(lineMult'1#) = [0] p(lineMult'2#) = [0] p(matrixMult#) = [4] x1 + [0] p(matrixMult'1#) = [4] x1 + [0] p(mult#) = [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [0] p(c_18) = [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [0] p(c_28) = [1] x1 + [0] p(c_29) = [1] x1 + [3] p(c_30) = [1] p(c_31) = [1] x1 + [0] p(c_32) = [0] p(c_33) = [1] x1 + [0] p(c_34) = [1] x1 + [0] p(c_35) = [0] p(c_36) = [2] p(c_37) = [4] p(c_38) = [1] x1 + [0] p(c_39) = [1] x1 + [1] x2 + [4] p(c_40) = [1] p(c_41) = [2] x1 + [4] Following rules are strictly oriented: computeLine'1#(dd(x,xs),acc,m) = [4] x + [4] xs + [4] > [4] x + [4] xs + [3] = c_29(computeLine'2#(m,acc,x,xs)) Following rules are (at-least) weakly oriented: computeLine#(line,m,acc) = [4] line + [0] >= [4] line + [0] = c_28(computeLine'1#(line,acc,m)) computeLine'2#(dd(l,ls),acc,x,xs) = [4] x + [4] xs + [0] >= [4] xs + [0] = c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) = [4] m1 + [0] >= [4] m1 + [0] = c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) = [4] l + [4] ls + [4] >= [4] l + [4] ls + [4] = c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) ****** Step 7.b:4.b:5.a:1.b:3.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) - Weak DPs: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/1 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ****** Step 7.b:4.b:5.a:1.b:3.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) - Weak DPs: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/1 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) Consider the set of all dependency pairs 1: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 2: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) 4: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 5: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1)) SPACE(?,?)on application of the dependency pairs {1} These cover all (indirect) predecessors of dependency pairs {1,2,3} their number of applications is equally bounded. The dependency pairs are shifted into the weak component. ******* Step 7.b:4.b:5.a:1.b:3.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) - Weak DPs: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/1 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_28) = {1}, uargs(c_29) = {1}, uargs(c_31) = {1}, uargs(c_38) = {1}, uargs(c_39) = {1,2} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [1] p('add) = [4] x1 + [0] p('mult) = [0] p('natadd) = [2] x1 + [0] p('natmult) = [4] x1 + [5] p('neg) = [1] p('pos) = [1] x1 + [1] p('pred) = [7] p('s) = [1] x1 + [0] p('succ) = [1] p(add) = [4] x1 + [0] p(computeLine) = [0] p(computeLine'1) = [0] p(computeLine'2) = [0] p(dd) = [1] x1 + [1] x2 + [2] p(lineMult) = [0] p(lineMult'1) = [0] p(lineMult'2) = [1] x1 + [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [1] x2 + [2] p(nil) = [0] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [1] x1 + [1] p(computeLine'1#) = [1] x1 + [0] p(computeLine'2#) = [1] x3 + [1] x4 + [1] p(lineMult#) = [0] p(lineMult'1#) = [0] p(lineMult'2#) = [0] p(matrixMult#) = [1] x1 + [2] p(matrixMult'1#) = [1] x1 + [1] p(mult#) = [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [0] p(c_17) = [0] p(c_18) = [0] p(c_19) = [0] p(c_20) = [0] p(c_21) = [0] p(c_22) = [0] p(c_23) = [0] p(c_24) = [0] p(c_25) = [0] p(c_26) = [0] p(c_27) = [1] x1 + [0] p(c_28) = [1] x1 + [0] p(c_29) = [1] x1 + [1] p(c_30) = [2] p(c_31) = [1] x1 + [0] p(c_32) = [0] p(c_33) = [1] x1 + [0] p(c_34) = [2] p(c_35) = [1] p(c_36) = [1] x1 + [4] p(c_37) = [0] p(c_38) = [1] x1 + [0] p(c_39) = [1] x1 + [1] x2 + [0] p(c_40) = [0] p(c_41) = [0] Following rules are strictly oriented: computeLine#(line,m,acc) = [1] line + [1] > [1] line + [0] = c_28(computeLine'1#(line,acc,m)) Following rules are (at-least) weakly oriented: computeLine'1#(dd(x,xs),acc,m) = [1] x + [1] xs + [2] >= [1] x + [1] xs + [2] = c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) = [1] x + [1] xs + [1] >= [1] xs + [1] = c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) = [1] m1 + [2] >= [1] m1 + [1] = c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) = [1] l + [1] ls + [3] >= [1] l + [1] ls + [3] = c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) ******* Step 7.b:4.b:5.a:1.b:3.b:1.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/1 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ******* Step 7.b:4.b:5.a:1.b:3.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/1 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):2 2:W:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))):3 3:W:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 4:W:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):5 5:W:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):4 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 4: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 5: matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) 1: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 3: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc))) 2: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) ******* Step 7.b:4.b:5.a:1.b:3.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/1 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). **** Step 7.b:4.b:5.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak DPs: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:S:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):2 2:S:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):3 -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):1 3:W:computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) -->_1 computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)):4 4:W:computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) -->_1 computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)) ,lineMult#(x,l,acc)):5 5:W:computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) -->_2 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):6 -->_1 computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)):3 6:W:lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) -->_1 lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)):7 7:W:lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) -->_1 lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())):9 -->_1 lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)):8 8:W:lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) -->_1 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):6 9:W:lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) -->_1 lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)):6 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 3: computeLine#(line,m,acc) -> c_28(computeLine'1#(line,acc,m)) 5: computeLine'2#(dd(l,ls),acc,x,xs) -> c_31(computeLine#(xs,ls,lineMult(x,l,acc)),lineMult#(x,l,acc)) 4: computeLine'1#(dd(x,xs),acc,m) -> c_29(computeLine'2#(m,acc,x,xs)) 6: lineMult#(n,l1,l2) -> c_33(lineMult'1#(l1,l2,n)) 9: lineMult'2#(nil(),n,x,xs) -> c_37(lineMult#(n,xs,nil())) 7: lineMult'1#(dd(x,xs),l2,n) -> c_34(lineMult'2#(l2,n,x,xs)) 8: lineMult'2#(dd(y,ys),n,x,xs) -> c_36(lineMult#(n,xs,ys)) **** Step 7.b:4.b:5.b:2: SimplifyRHS WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/2,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: SimplifyRHS + Details: Consider the dependency graph 1:S:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)):2 2:S:matrixMult'1#(dd(l,ls),m2) -> c_39(computeLine#(l,m2,nil()),matrixMult#(ls,m2)) -->_2 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):1 Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified: matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) **** Step 7.b:4.b:5.b:3: UsableRules WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) - Weak TRS: 'add('0(),y) -> y 'add('neg('s('0())),y) -> 'pred(y) 'add('neg('s('s(x))),y) -> 'pred('add('pos('s(x)),y)) 'add('pos('s('0())),y) -> 'succ(y) 'add('pos('s('s(x))),y) -> 'succ('add('pos('s(x)),y)) 'mult('0(),'0()) -> '0() 'mult('0(),'neg(y)) -> '0() 'mult('0(),'pos(y)) -> '0() 'mult('neg(x),'0()) -> '0() 'mult('neg(x),'neg(y)) -> 'pos('natmult(x,y)) 'mult('neg(x),'pos(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'0()) -> '0() 'mult('pos(x),'neg(y)) -> 'neg('natmult(x,y)) 'mult('pos(x),'pos(y)) -> 'pos('natmult(x,y)) 'natadd('0(),y) -> y 'natadd('s(x),y) -> 's('natadd(x,y)) 'natmult('0(),y) -> '0() 'natmult('s(x),y) -> 'natadd(y,'natmult(x,y)) 'pred('0()) -> 'neg('s('0())) 'pred('neg('s(x))) -> 'neg('s('s(x))) 'pred('pos('s('0()))) -> '0() 'pred('pos('s('s(x)))) -> 'pos('s(x)) 'succ('0()) -> 'pos('s('0())) 'succ('neg('s('0()))) -> '0() 'succ('neg('s('s(x)))) -> 'neg('s(x)) 'succ('pos('s(x))) -> 'pos('s('s(x))) add(x,y) -> 'add(x,y) lineMult(n,l1,l2) -> lineMult'1(l1,l2,n) lineMult'1(dd(x,xs),l2,n) -> lineMult'2(l2,n,x,xs) lineMult'1(nil(),l2,n) -> nil() lineMult'2(dd(y,ys),n,x,xs) -> dd(add(mult(x,n),y),lineMult(n,xs,ys)) lineMult'2(nil(),n,x,xs) -> dd(mult(x,n),lineMult(n,xs,nil())) mult(x,y) -> 'mult(x,y) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/1,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: UsableRules + Details: We replace rewrite rules by usable rules: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) **** Step 7.b:4.b:5.b:4: PredecessorEstimationCP WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/1,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}} + Details: We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly: 1: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 2: matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) The strictly oriented rules are moved into the weak component. ***** Step 7.b:4.b:5.b:4.a:1: NaturalMI WORST_CASE(?,O(n^1)) + Considered Problem: - Strict DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/1,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules} + Details: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(c_38) = {1}, uargs(c_39) = {1} Following symbols are considered usable: {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add#,computeLine#,computeLine'1#,computeLine'2#,lineMult# ,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1#,mult#} TcT has computed the following interpretation: p('0) = [0] p('add) = [0] p('mult) = [0] p('natadd) = [0] p('natmult) = [0] p('neg) = [1] x1 + [0] p('pos) = [0] p('pred) = [1] x1 + [0] p('s) = [0] p('succ) = [0] p(add) = [1] p(computeLine) = [0] p(computeLine'1) = [1] x1 + [2] x2 + [2] x3 + [8] p(computeLine'2) = [8] x2 + [4] p(dd) = [1] x2 + [1] p(lineMult) = [1] x1 + [8] x2 + [1] p(lineMult'1) = [0] p(lineMult'2) = [0] p(matrixMult) = [0] p(matrixMult'1) = [0] p(mult) = [0] p(nil) = [0] p('add#) = [0] p('mult#) = [0] p('natadd#) = [0] p('natmult#) = [0] p('pred#) = [0] p('succ#) = [0] p(add#) = [0] p(computeLine#) = [0] p(computeLine'1#) = [0] p(computeLine'2#) = [0] p(lineMult#) = [0] p(lineMult'1#) = [0] p(lineMult'2#) = [0] p(matrixMult#) = [8] x1 + [1] p(matrixMult'1#) = [8] x1 + [0] p(mult#) = [0] p(c_1) = [0] p(c_2) = [0] p(c_3) = [0] p(c_4) = [0] p(c_5) = [0] p(c_6) = [0] p(c_7) = [0] p(c_8) = [0] p(c_9) = [0] p(c_10) = [0] p(c_11) = [0] p(c_12) = [0] p(c_13) = [0] p(c_14) = [0] p(c_15) = [0] p(c_16) = [1] p(c_17) = [1] p(c_18) = [1] x2 + [4] p(c_19) = [0] p(c_20) = [0] p(c_21) = [1] p(c_22) = [8] p(c_23) = [8] p(c_24) = [8] p(c_25) = [1] p(c_26) = [1] p(c_27) = [2] x1 + [1] p(c_28) = [1] x1 + [0] p(c_29) = [1] x1 + [8] p(c_30) = [1] p(c_31) = [4] x1 + [2] x2 + [8] p(c_32) = [0] p(c_33) = [8] x1 + [1] p(c_34) = [1] x1 + [1] p(c_35) = [1] p(c_36) = [1] x1 + [0] p(c_37) = [2] x1 + [2] p(c_38) = [1] x1 + [0] p(c_39) = [1] x1 + [1] p(c_40) = [8] p(c_41) = [2] Following rules are strictly oriented: matrixMult#(m1,m2) = [8] m1 + [1] > [8] m1 + [0] = c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) = [8] ls + [8] > [8] ls + [2] = c_39(matrixMult#(ls,m2)) Following rules are (at-least) weakly oriented: ***** Step 7.b:4.b:5.b:4.a:2: Assumption WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/1,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}} + Details: () ***** Step 7.b:4.b:5.b:4.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1)) + Considered Problem: - Weak DPs: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/1,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: RemoveWeakSuffixes + Details: Consider the dependency graph 1:W:matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) -->_1 matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)):2 2:W:matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) -->_1 matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)):1 The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. 1: matrixMult#(m1,m2) -> c_38(matrixMult'1#(m1,m2)) 2: matrixMult'1#(dd(l,ls),m2) -> c_39(matrixMult#(ls,m2)) ***** Step 7.b:4.b:5.b:4.b:2: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Signature: {'add/2,'mult/2,'natadd/2,'natmult/2,'pred/1,'succ/1,add/2,computeLine/3,computeLine'1/3,computeLine'2/4 ,lineMult/3,lineMult'1/3,lineMult'2/4,matrixMult/2,matrixMult'1/2,mult/2,'add#/2,'mult#/2,'natadd#/2 ,'natmult#/2,'pred#/1,'succ#/1,add#/2,computeLine#/3,computeLine'1#/3,computeLine'2#/4,lineMult#/3 ,lineMult'1#/3,lineMult'2#/4,matrixMult#/2,matrixMult'1#/2,mult#/2} / {'0/0,'neg/1,'pos/1,'s/1,dd/2,nil/0 ,c_1/0,c_2/1,c_3/1,c_4/1,c_5/1,c_6/0,c_7/0,c_8/0,c_9/0,c_10/1,c_11/1,c_12/0,c_13/1,c_14/1,c_15/0,c_16/1 ,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/1,c_28/1,c_29/1,c_30/0,c_31/2 ,c_32/0,c_33/1,c_34/1,c_35/0,c_36/1,c_37/1,c_38/1,c_39/1,c_40/0,c_41/1} - Obligation: innermost runtime complexity wrt. defined symbols {'add#,'mult#,'natadd#,'natmult#,'pred#,'succ#,add# ,computeLine#,computeLine'1#,computeLine'2#,lineMult#,lineMult'1#,lineMult'2#,matrixMult#,matrixMult'1# ,mult#} and constructors {'0,'neg,'pos,'s,dd,nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). MAYBE