WORST_CASE(?,O(n^2)) * Step 1: WeightGap WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: dx(X) -> one() dx(a()) -> zero() dx(div(ALPHA,BETA)) -> minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two())))) dx(exp(ALPHA,BETA)) -> plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA))) ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA)))) dx(ln(ALPHA)) -> div(dx(ALPHA),ALPHA) dx(minus(ALPHA,BETA)) -> minus(dx(ALPHA),dx(BETA)) dx(neg(ALPHA)) -> neg(dx(ALPHA)) dx(plus(ALPHA,BETA)) -> plus(dx(ALPHA),dx(BETA)) dx(times(ALPHA,BETA)) -> plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA))) - Signature: {dx/1} / {a/0,div/2,exp/2,ln/1,minus/2,neg/1,one/0,plus/2,times/2,two/0,zero/0} - Obligation: innermost runtime complexity wrt. defined symbols {dx} and constructors {a,div,exp,ln,minus,neg,one,plus ,times,two,zero} + 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(div) = {1}, uargs(minus) = {1,2}, uargs(neg) = {1}, uargs(plus) = {1,2}, uargs(times) = {2} Following symbols are considered usable: all TcT has computed the following interpretation: p(a) = [0] p(div) = [1] x1 + [0] p(dx) = [1] p(exp) = [1] x2 + [2] p(ln) = [2] p(minus) = [1] x1 + [1] x2 + [1] p(neg) = [1] x1 + [0] p(one) = [0] p(plus) = [1] x1 + [1] x2 + [5] p(times) = [1] x2 + [0] p(two) = [1] p(zero) = [0] Following rules are strictly oriented: dx(X) = [1] > [0] = one() dx(a()) = [1] > [0] = zero() Following rules are (at-least) weakly oriented: dx(div(ALPHA,BETA)) = [1] >= [3] = minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two())))) dx(exp(ALPHA,BETA)) = [1] >= [7] = plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA))) ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA)))) dx(ln(ALPHA)) = [1] >= [1] = div(dx(ALPHA),ALPHA) dx(minus(ALPHA,BETA)) = [1] >= [3] = minus(dx(ALPHA),dx(BETA)) dx(neg(ALPHA)) = [1] >= [1] = neg(dx(ALPHA)) dx(plus(ALPHA,BETA)) = [1] >= [7] = plus(dx(ALPHA),dx(BETA)) dx(times(ALPHA,BETA)) = [1] >= [7] = plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA))) Further, it can be verified that all rules not oriented are covered by the weightgap condition. * Step 2: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: dx(div(ALPHA,BETA)) -> minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two())))) dx(exp(ALPHA,BETA)) -> plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA))) ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA)))) dx(ln(ALPHA)) -> div(dx(ALPHA),ALPHA) dx(minus(ALPHA,BETA)) -> minus(dx(ALPHA),dx(BETA)) dx(neg(ALPHA)) -> neg(dx(ALPHA)) dx(plus(ALPHA,BETA)) -> plus(dx(ALPHA),dx(BETA)) dx(times(ALPHA,BETA)) -> plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA))) - Weak TRS: dx(X) -> one() dx(a()) -> zero() - Signature: {dx/1} / {a/0,div/2,exp/2,ln/1,minus/2,neg/1,one/0,plus/2,times/2,two/0,zero/0} - Obligation: innermost runtime complexity wrt. defined symbols {dx} and constructors {a,div,exp,ln,minus,neg,one,plus ,times,two,zero} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(div) = {1}, uargs(minus) = {1,2}, uargs(neg) = {1}, uargs(plus) = {1,2}, uargs(times) = {2} Following symbols are considered usable: {dx} TcT has computed the following interpretation: p(a) = 0 p(div) = 2 + x1 + x2 p(dx) = 4*x1 + x1^2 p(exp) = 2 + x1 + x2 p(ln) = 1 + x1 p(minus) = 2 + x1 + x2 p(neg) = x1 p(one) = 0 p(plus) = x1 + x2 p(times) = 1 + x1 + x2 p(two) = 0 p(zero) = 0 Following rules are strictly oriented: dx(div(ALPHA,BETA)) = 12 + 8*ALPHA + 2*ALPHA*BETA + ALPHA^2 + 8*BETA + BETA^2 > 9 + 5*ALPHA + ALPHA^2 + 6*BETA + BETA^2 = minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two())))) dx(exp(ALPHA,BETA)) = 12 + 8*ALPHA + 2*ALPHA*BETA + ALPHA^2 + 8*BETA + BETA^2 > 11 + 7*ALPHA + ALPHA^2 + 7*BETA + BETA^2 = plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA))) ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA)))) dx(ln(ALPHA)) = 5 + 6*ALPHA + ALPHA^2 > 2 + 5*ALPHA + ALPHA^2 = div(dx(ALPHA),ALPHA) dx(minus(ALPHA,BETA)) = 12 + 8*ALPHA + 2*ALPHA*BETA + ALPHA^2 + 8*BETA + BETA^2 > 2 + 4*ALPHA + ALPHA^2 + 4*BETA + BETA^2 = minus(dx(ALPHA),dx(BETA)) dx(times(ALPHA,BETA)) = 5 + 6*ALPHA + 2*ALPHA*BETA + ALPHA^2 + 6*BETA + BETA^2 > 2 + 5*ALPHA + ALPHA^2 + 5*BETA + BETA^2 = plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA))) Following rules are (at-least) weakly oriented: dx(X) = 4*X + X^2 >= 0 = one() dx(a()) = 0 >= 0 = zero() dx(neg(ALPHA)) = 4*ALPHA + ALPHA^2 >= 4*ALPHA + ALPHA^2 = neg(dx(ALPHA)) dx(plus(ALPHA,BETA)) = 4*ALPHA + 2*ALPHA*BETA + ALPHA^2 + 4*BETA + BETA^2 >= 4*ALPHA + ALPHA^2 + 4*BETA + BETA^2 = plus(dx(ALPHA),dx(BETA)) * Step 3: NaturalPI WORST_CASE(?,O(n^2)) + Considered Problem: - Strict TRS: dx(neg(ALPHA)) -> neg(dx(ALPHA)) dx(plus(ALPHA,BETA)) -> plus(dx(ALPHA),dx(BETA)) - Weak TRS: dx(X) -> one() dx(a()) -> zero() dx(div(ALPHA,BETA)) -> minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two())))) dx(exp(ALPHA,BETA)) -> plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA))) ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA)))) dx(ln(ALPHA)) -> div(dx(ALPHA),ALPHA) dx(minus(ALPHA,BETA)) -> minus(dx(ALPHA),dx(BETA)) dx(times(ALPHA,BETA)) -> plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA))) - Signature: {dx/1} / {a/0,div/2,exp/2,ln/1,minus/2,neg/1,one/0,plus/2,times/2,two/0,zero/0} - Obligation: innermost runtime complexity wrt. defined symbols {dx} and constructors {a,div,exp,ln,minus,neg,one,plus ,times,two,zero} + Applied Processor: NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: We apply a polynomial interpretation of kind constructor-based(mixed(2)): The following argument positions are considered usable: uargs(div) = {1}, uargs(minus) = {1,2}, uargs(neg) = {1}, uargs(plus) = {1,2}, uargs(times) = {2} Following symbols are considered usable: {dx} TcT has computed the following interpretation: p(a) = 0 p(div) = 2 + x1 + x2 p(dx) = 2*x1 + 2*x1^2 p(exp) = 2 + x1 + x2 p(ln) = 1 + x1 p(minus) = 2 + x1 + x2 p(neg) = 2 + x1 p(one) = 0 p(plus) = 1 + x1 + x2 p(times) = 1 + x1 + x2 p(two) = 2 p(zero) = 0 Following rules are strictly oriented: dx(neg(ALPHA)) = 12 + 10*ALPHA + 2*ALPHA^2 > 2 + 2*ALPHA + 2*ALPHA^2 = neg(dx(ALPHA)) dx(plus(ALPHA,BETA)) = 4 + 6*ALPHA + 4*ALPHA*BETA + 2*ALPHA^2 + 6*BETA + 2*BETA^2 > 1 + 2*ALPHA + 2*ALPHA^2 + 2*BETA + 2*BETA^2 = plus(dx(ALPHA),dx(BETA)) Following rules are (at-least) weakly oriented: dx(X) = 2*X + 2*X^2 >= 0 = one() dx(a()) = 0 >= 0 = zero() dx(div(ALPHA,BETA)) = 12 + 10*ALPHA + 4*ALPHA*BETA + 2*ALPHA^2 + 10*BETA + 2*BETA^2 >= 11 + 3*ALPHA + 2*ALPHA^2 + 4*BETA + 2*BETA^2 = minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two())))) dx(exp(ALPHA,BETA)) = 12 + 10*ALPHA + 4*ALPHA*BETA + 2*ALPHA^2 + 10*BETA + 2*BETA^2 >= 12 + 5*ALPHA + 2*ALPHA^2 + 5*BETA + 2*BETA^2 = plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA))) ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA)))) dx(ln(ALPHA)) = 4 + 6*ALPHA + 2*ALPHA^2 >= 2 + 3*ALPHA + 2*ALPHA^2 = div(dx(ALPHA),ALPHA) dx(minus(ALPHA,BETA)) = 12 + 10*ALPHA + 4*ALPHA*BETA + 2*ALPHA^2 + 10*BETA + 2*BETA^2 >= 2 + 2*ALPHA + 2*ALPHA^2 + 2*BETA + 2*BETA^2 = minus(dx(ALPHA),dx(BETA)) dx(times(ALPHA,BETA)) = 4 + 6*ALPHA + 4*ALPHA*BETA + 2*ALPHA^2 + 6*BETA + 2*BETA^2 >= 3 + 3*ALPHA + 2*ALPHA^2 + 3*BETA + 2*BETA^2 = plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA))) * Step 4: EmptyProcessor WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: dx(X) -> one() dx(a()) -> zero() dx(div(ALPHA,BETA)) -> minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two())))) dx(exp(ALPHA,BETA)) -> plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA))) ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA)))) dx(ln(ALPHA)) -> div(dx(ALPHA),ALPHA) dx(minus(ALPHA,BETA)) -> minus(dx(ALPHA),dx(BETA)) dx(neg(ALPHA)) -> neg(dx(ALPHA)) dx(plus(ALPHA,BETA)) -> plus(dx(ALPHA),dx(BETA)) dx(times(ALPHA,BETA)) -> plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA))) - Signature: {dx/1} / {a/0,div/2,exp/2,ln/1,minus/2,neg/1,one/0,plus/2,times/2,two/0,zero/0} - Obligation: innermost runtime complexity wrt. defined symbols {dx} and constructors {a,div,exp,ln,minus,neg,one,plus ,times,two,zero} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). WORST_CASE(?,O(n^2))