WORST_CASE(?,O(n^3)) * Step 1: WeightGap WORST_CASE(?,O(n^3)) + Considered Problem: - Strict TRS: add(0(),X) -> X add(s(X),Y) -> s(add(X,Y)) dbl(0()) -> 0() dbl(s(X)) -> s(s(dbl(X))) first(0(),X) -> nil() first(s(X),cons(Y)) -> cons(Y) sqr(0()) -> 0() sqr(s(X)) -> s(add(sqr(X),dbl(X))) terms(N) -> cons(recip(sqr(N))) - Signature: {add/2,dbl/1,first/2,sqr/1,terms/1} / {0/0,cons/1,nil/0,recip/1,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,dbl,first,sqr,terms} and constructors {0,cons,nil ,recip,s} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following nonconstant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(add) = {1,2}, uargs(cons) = {1}, uargs(recip) = {1}, uargs(s) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(0) = [1] p(add) = [1] x1 + [1] x2 + [0] p(cons) = [1] x1 + [0] p(dbl) = [0] p(first) = [8] x1 + [2] x2 + [0] p(nil) = [0] p(recip) = [1] x1 + [0] p(s) = [1] x1 + [2] p(sqr) = [2] p(terms) = [2] Following rules are strictly oriented: add(0(),X) = [1] X + [1] > [1] X + [0] = X first(0(),X) = [2] X + [8] > [0] = nil() first(s(X),cons(Y)) = [8] X + [2] Y + [16] > [1] Y + [0] = cons(Y) sqr(0()) = [2] > [1] = 0() Following rules are (at-least) weakly oriented: add(s(X),Y) = [1] X + [1] Y + [2] >= [1] X + [1] Y + [2] = s(add(X,Y)) dbl(0()) = [0] >= [1] = 0() dbl(s(X)) = [0] >= [4] = s(s(dbl(X))) sqr(s(X)) = [2] >= [4] = s(add(sqr(X),dbl(X))) terms(N) = [2] >= [2] = cons(recip(sqr(N))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. * Step 2: WeightGap WORST_CASE(?,O(n^3)) + Considered Problem: - Strict TRS: add(s(X),Y) -> s(add(X,Y)) dbl(0()) -> 0() dbl(s(X)) -> s(s(dbl(X))) sqr(s(X)) -> s(add(sqr(X),dbl(X))) terms(N) -> cons(recip(sqr(N))) - Weak TRS: add(0(),X) -> X first(0(),X) -> nil() first(s(X),cons(Y)) -> cons(Y) sqr(0()) -> 0() - Signature: {add/2,dbl/1,first/2,sqr/1,terms/1} / {0/0,cons/1,nil/0,recip/1,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,dbl,first,sqr,terms} and constructors {0,cons,nil ,recip,s} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following nonconstant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(add) = {1,2}, uargs(cons) = {1}, uargs(recip) = {1}, uargs(s) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(0) = [0] p(add) = [1] x1 + [1] x2 + [0] p(cons) = [1] x1 + [0] p(dbl) = [0] p(first) = [2] x2 + [0] p(nil) = [0] p(recip) = [1] x1 + [0] p(s) = [1] x1 + [0] p(sqr) = [0] p(terms) = [1] Following rules are strictly oriented: terms(N) = [1] > [0] = cons(recip(sqr(N))) Following rules are (at-least) weakly oriented: add(0(),X) = [1] X + [0] >= [1] X + [0] = X add(s(X),Y) = [1] X + [1] Y + [0] >= [1] X + [1] Y + [0] = s(add(X,Y)) dbl(0()) = [0] >= [0] = 0() dbl(s(X)) = [0] >= [0] = s(s(dbl(X))) first(0(),X) = [2] X + [0] >= [0] = nil() first(s(X),cons(Y)) = [2] Y + [0] >= [1] Y + [0] = cons(Y) sqr(0()) = [0] >= [0] = 0() sqr(s(X)) = [0] >= [0] = s(add(sqr(X),dbl(X))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. * Step 3: WeightGap WORST_CASE(?,O(n^3)) + Considered Problem: - Strict TRS: add(s(X),Y) -> s(add(X,Y)) dbl(0()) -> 0() dbl(s(X)) -> s(s(dbl(X))) sqr(s(X)) -> s(add(sqr(X),dbl(X))) - Weak TRS: add(0(),X) -> X first(0(),X) -> nil() first(s(X),cons(Y)) -> cons(Y) sqr(0()) -> 0() terms(N) -> cons(recip(sqr(N))) - Signature: {add/2,dbl/1,first/2,sqr/1,terms/1} / {0/0,cons/1,nil/0,recip/1,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,dbl,first,sqr,terms} and constructors {0,cons,nil ,recip,s} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following nonconstant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(add) = {1,2}, uargs(cons) = {1}, uargs(recip) = {1}, uargs(s) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(0) = [1] p(add) = [1] x1 + [1] x2 + [3] p(cons) = [1] x1 + [2] p(dbl) = [13] p(first) = [8] x2 + [2] p(nil) = [2] p(recip) = [1] x1 + [10] p(s) = [1] x1 + [5] p(sqr) = [4] x1 + [2] p(terms) = [5] x1 + [14] Following rules are strictly oriented: dbl(0()) = [13] > [1] = 0() Following rules are (at-least) weakly oriented: add(0(),X) = [1] X + [4] >= [1] X + [0] = X add(s(X),Y) = [1] X + [1] Y + [8] >= [1] X + [1] Y + [8] = s(add(X,Y)) dbl(s(X)) = [13] >= [23] = s(s(dbl(X))) first(0(),X) = [8] X + [2] >= [2] = nil() first(s(X),cons(Y)) = [8] Y + [18] >= [1] Y + [2] = cons(Y) sqr(0()) = [6] >= [1] = 0() sqr(s(X)) = [4] X + [22] >= [4] X + [23] = s(add(sqr(X),dbl(X))) terms(N) = [5] N + [14] >= [4] N + [14] = cons(recip(sqr(N))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. * Step 4: WeightGap WORST_CASE(?,O(n^3)) + Considered Problem: - Strict TRS: add(s(X),Y) -> s(add(X,Y)) dbl(s(X)) -> s(s(dbl(X))) sqr(s(X)) -> s(add(sqr(X),dbl(X))) - Weak TRS: add(0(),X) -> X dbl(0()) -> 0() first(0(),X) -> nil() first(s(X),cons(Y)) -> cons(Y) sqr(0()) -> 0() terms(N) -> cons(recip(sqr(N))) - Signature: {add/2,dbl/1,first/2,sqr/1,terms/1} / {0/0,cons/1,nil/0,recip/1,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,dbl,first,sqr,terms} and constructors {0,cons,nil ,recip,s} + Applied Processor: WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny} + Details: The weightgap principle applies using the following nonconstant growth matrix-interpretation: We apply a matrix interpretation of kind constructor based matrix interpretation: The following argument positions are considered usable: uargs(add) = {1,2}, uargs(cons) = {1}, uargs(recip) = {1}, uargs(s) = {1} Following symbols are considered usable: all TcT has computed the following interpretation: p(0) = [1] p(add) = [1] x1 + [1] x2 + [0] p(cons) = [1] x1 + [4] p(dbl) = [1] p(first) = [8] x1 + [2] x2 + [13] p(nil) = [2] p(recip) = [1] x1 + [8] p(s) = [1] x1 + [1] p(sqr) = [8] x1 + [3] p(terms) = [8] x1 + [15] Following rules are strictly oriented: sqr(s(X)) = [8] X + [11] > [8] X + [5] = s(add(sqr(X),dbl(X))) Following rules are (at-least) weakly oriented: add(0(),X) = [1] X + [1] >= [1] X + [0] = X add(s(X),Y) = [1] X + [1] Y + [1] >= [1] X + [1] Y + [1] = s(add(X,Y)) dbl(0()) = [1] >= [1] = 0() dbl(s(X)) = [1] >= [3] = s(s(dbl(X))) first(0(),X) = [2] X + [21] >= [2] = nil() first(s(X),cons(Y)) = [8] X + [2] Y + [29] >= [1] Y + [4] = cons(Y) sqr(0()) = [11] >= [1] = 0() terms(N) = [8] N + [15] >= [8] N + [15] = cons(recip(sqr(N))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. * Step 5: Ara WORST_CASE(?,O(n^3)) + Considered Problem: - Strict TRS: add(s(X),Y) -> s(add(X,Y)) dbl(s(X)) -> s(s(dbl(X))) - Weak TRS: add(0(),X) -> X dbl(0()) -> 0() first(0(),X) -> nil() first(s(X),cons(Y)) -> cons(Y) sqr(0()) -> 0() sqr(s(X)) -> s(add(sqr(X),dbl(X))) terms(N) -> cons(recip(sqr(N))) - Signature: {add/2,dbl/1,first/2,sqr/1,terms/1} / {0/0,cons/1,nil/0,recip/1,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,dbl,first,sqr,terms} and constructors {0,cons,nil ,recip,s} + Applied Processor: Ara {heuristics_ = NoHeuristics, minDegree = 2, maxDegree = 2, araTimeout = 15, araFindStrictRules = Just 1} + Details: Signatures used: ---------------- 0 :: [] -(0)-> A(1, 0) 0 :: [] -(0)-> A(13, 0) 0 :: [] -(0)-> A(0, 1) 0 :: [] -(0)-> A(0, 15) 0 :: [] -(0)-> A(5, 7) 0 :: [] -(0)-> A(7, 7) add :: [A(1, 0) x A(2, 0)] -(1)-> A(1, 0) cons :: [A(0, 0)] -(4)-> A(4, 4) cons :: [A(0, 0)] -(5)-> A(5, 10) cons :: [A(0, 0)] -(0)-> A(0, 2) dbl :: [A(13, 0)] -(5)-> A(2, 0) first :: [A(0, 1) x A(4, 4)] -(14)-> A(0, 0) nil :: [] -(0)-> A(6, 14) recip :: [A(0, 0)] -(13)-> A(13, 12) s :: [A(1, 0)] -(1)-> A(1, 0) s :: [A(13, 0)] -(13)-> A(13, 0) s :: [A(1, 1)] -(1)-> A(0, 1) s :: [A(15, 15)] -(15)-> A(0, 15) s :: [A(2, 0)] -(2)-> A(2, 0) sqr :: [A(0, 15)] -(1)-> A(1, 0) terms :: [A(14, 15)] -(15)-> A(0, 0) Cost-free Signatures used: -------------------------- 0 :: [] -(0)-> A_cf(0, 0) 0 :: [] -(0)-> A_cf(2, 2) 0 :: [] -(0)-> A_cf(2, 0) add :: [A_cf(0, 0) x A_cf(0, 0)] -(0)-> A_cf(0, 0) dbl :: [A_cf(0, 0)] -(1)-> A_cf(0, 0) dbl :: [A_cf(0, 0)] -(0)-> A_cf(0, 0) s :: [A_cf(0, 0)] -(0)-> A_cf(0, 0) s :: [A_cf(2, 0)] -(2)-> A_cf(2, 0) sqr :: [A_cf(2, 0)] -(7)-> A_cf(0, 0) Base Constructor Signatures used: --------------------------------- 0_A :: [] -(0)-> A(1, 0) 0_A :: [] -(0)-> A(0, 1) cons_A :: [A(0, 0)] -(1)-> A(1, 0) cons_A :: [A(0, 0)] -(0)-> A(0, 1) nil_A :: [] -(0)-> A(1, 0) nil_A :: [] -(0)-> A(0, 1) recip_A :: [A(0, 0)] -(1)-> A(1, 0) recip_A :: [A(0, 0)] -(0)-> A(0, 1) s_A :: [A(1, 0)] -(1)-> A(1, 0) s_A :: [A(1, 1)] -(1)-> A(0, 1) Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: dbl(s(X)) -> s(s(dbl(X))) 2. Weak: add(s(X),Y) -> s(add(X,Y)) * Step 6: Ara WORST_CASE(?,O(n^3)) + Considered Problem: - Strict TRS: add(s(X),Y) -> s(add(X,Y)) - Weak TRS: add(0(),X) -> X dbl(0()) -> 0() dbl(s(X)) -> s(s(dbl(X))) first(0(),X) -> nil() first(s(X),cons(Y)) -> cons(Y) sqr(0()) -> 0() sqr(s(X)) -> s(add(sqr(X),dbl(X))) terms(N) -> cons(recip(sqr(N))) - Signature: {add/2,dbl/1,first/2,sqr/1,terms/1} / {0/0,cons/1,nil/0,recip/1,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,dbl,first,sqr,terms} and constructors {0,cons,nil ,recip,s} + Applied Processor: Ara {heuristics_ = NoHeuristics, minDegree = 3, maxDegree = 3, araTimeout = 15, araFindStrictRules = Just 1} + Details: Signatures used: ---------------- 0 :: [] -(0)-> A(1, 0, 0) 0 :: [] -(0)-> A(9, 0, 0) 0 :: [] -(0)-> A(0, 0, 2) 0 :: [] -(0)-> A(0, 0, 15) 0 :: [] -(0)-> A(1, 1, 7) add :: [A(1, 0, 0) x A(0, 0, 0)] -(1)-> A(0, 0, 0) cons :: [A(9, 0, 0)] -(9)-> A(0, 9, 10) cons :: [A(1, 0, 0)] -(1)-> A(8, 1, 3) cons :: [A(2, 0, 0)] -(2)-> A(6, 2, 0) dbl :: [A(9, 0, 0)] -(3)-> A(0, 0, 0) first :: [A(0, 0, 2) x A(0, 9, 10)] -(9)-> A(1, 1, 0) nil :: [] -(0)-> A(4, 4, 6) recip :: [A(0, 0, 0)] -(0)-> A(8, 6, 0) s :: [A(1, 0, 0)] -(1)-> A(1, 0, 0) s :: [A(9, 0, 0)] -(9)-> A(9, 0, 0) s :: [A(2, 2, 2)] -(2)-> A(0, 0, 2) s :: [A(15, 15, 15)] -(15)-> A(0, 0, 15) s :: [A(0, 0, 0)] -(0)-> A(0, 0, 0) sqr :: [A(0, 0, 15)] -(0)-> A(0, 0, 0) terms :: [A(14, 14, 15)] -(15)-> A(0, 0, 0) Cost-free Signatures used: -------------------------- 0 :: [] -(0)-> A_cf(0, 0, 0) 0 :: [] -(0)-> A_cf(10, 2, 2) 0 :: [] -(0)-> A_cf(0, 15, 0) 0 :: [] -(0)-> A_cf(9, 3, 2) 0 :: [] -(0)-> A_cf(1, 0, 0) 0 :: [] -(0)-> A_cf(15, 0, 0) 0 :: [] -(0)-> A_cf(7, 10, 2) add :: [A_cf(0, 0, 0) x A_cf(0, 0, 0)] -(0)-> A_cf(0, 0, 0) add :: [A_cf(1, 0, 0) x A_cf(1, 0, 0)] -(1)-> A_cf(1, 0, 0) dbl :: [A_cf(0, 0, 0)] -(4)-> A_cf(0, 0, 0) dbl :: [A_cf(15, 0, 0)] -(3)-> A_cf(2, 0, 0) s :: [A_cf(0, 0, 0)] -(0)-> A_cf(0, 0, 0) s :: [A_cf(15, 15, 0)] -(15)-> A_cf(0, 15, 0) s :: [A_cf(1, 0, 0)] -(1)-> A_cf(1, 0, 0) s :: [A_cf(15, 0, 0)] -(15)-> A_cf(15, 0, 0) s :: [A_cf(2, 0, 0)] -(2)-> A_cf(2, 0, 0) sqr :: [A_cf(0, 15, 0)] -(0)-> A_cf(1, 0, 0) Base Constructor Signatures used: --------------------------------- 0_A :: [] -(0)-> A(1, 0, 0) 0_A :: [] -(0)-> A(0, 1, 0) 0_A :: [] -(0)-> A(0, 0, 1) cons_A :: [A(0, 0, 0)] -(0)-> A(1, 0, 0) cons_A :: [A(1, 0, 0)] -(1)-> A(0, 1, 0) cons_A :: [A(0, 0, 0)] -(0)-> A(0, 0, 1) nil_A :: [] -(0)-> A(1, 0, 0) nil_A :: [] -(0)-> A(0, 1, 0) nil_A :: [] -(0)-> A(0, 0, 1) recip_A :: [A(0, 0, 0)] -(0)-> A(1, 0, 0) recip_A :: [A(0, 0, 0)] -(0)-> A(0, 1, 0) recip_A :: [A(1, 1, 1)] -(1)-> A(0, 0, 1) s_A :: [A(1, 0, 0)] -(1)-> A(1, 0, 0) s_A :: [A(1, 1, 0)] -(1)-> A(0, 1, 0) s_A :: [A(1, 1, 1)] -(1)-> A(0, 0, 1) Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: add(s(X),Y) -> s(add(X,Y)) 2. Weak: * Step 7: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: add(0(),X) -> X add(s(X),Y) -> s(add(X,Y)) dbl(0()) -> 0() dbl(s(X)) -> s(s(dbl(X))) first(0(),X) -> nil() first(s(X),cons(Y)) -> cons(Y) sqr(0()) -> 0() sqr(s(X)) -> s(add(sqr(X),dbl(X))) terms(N) -> cons(recip(sqr(N))) - Signature: {add/2,dbl/1,first/2,sqr/1,terms/1} / {0/0,cons/1,nil/0,recip/1,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,dbl,first,sqr,terms} and constructors {0,cons,nil ,recip,s} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). WORST_CASE(?,O(n^3))