/export/starexec/sandbox2/solver/bin/starexec_run_complexity /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


--------------------------------------------------------------------------------


WORST_CASE(Omega(n^1), O(n^1))
proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml
# AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, n^1).

(0) CpxTRS
(1) CpxTrsToCdtProof [UPPER BOUND(ID), 10 ms]
(2) CdtProblem
    (3) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (4) CdtProblem
    (5) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (6) CdtProblem
    (7) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 46 ms]
    (8) CdtProblem
    (9) SIsEmptyProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) BOUNDS(1, 1)
(11) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(12) CpxTRS
    (13) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (14) typed CpxTrs
    (15) OrderProof [LOWER BOUND(ID), 0 ms]
    (16) typed CpxTrs
    (17) RewriteLemmaProof [LOWER BOUND(ID), 1070 ms]
    (18) proven lower bound
    (19) LowerBoundPropagationProof [FINISHED, 0 ms]
    (20) BOUNDS(n^1, INF)


----------------------------------------

(0)
Obligation:
The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, n^1).


The TRS R consists of the following rules:

   dx(X) -> one
   dx(a) -> zero
   dx(plus(ALPHA, BETA)) -> plus(dx(ALPHA), dx(BETA))
   dx(times(ALPHA, BETA)) -> plus(times(BETA, dx(ALPHA)), times(ALPHA, dx(BETA)))
   dx(minus(ALPHA, BETA)) -> minus(dx(ALPHA), dx(BETA))
   dx(neg(ALPHA)) -> neg(dx(ALPHA))
   dx(div(ALPHA, BETA)) -> minus(div(dx(ALPHA), BETA), times(ALPHA, div(dx(BETA), exp(BETA, two))))
   dx(ln(ALPHA)) -> div(dx(ALPHA), ALPHA)
   dx(exp(ALPHA, BETA)) -> plus(times(BETA, times(exp(ALPHA, minus(BETA, one)), dx(ALPHA))), times(exp(ALPHA, BETA), times(ln(ALPHA), dx(BETA))))

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(1) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS to CDT
----------------------------------------

(2)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   dx(z0) -> one
   dx(a) -> zero
   dx(plus(z0, z1)) -> plus(dx(z0), dx(z1))
   dx(times(z0, z1)) -> plus(times(z1, dx(z0)), times(z0, dx(z1)))
   dx(minus(z0, z1)) -> minus(dx(z0), dx(z1))
   dx(neg(z0)) -> neg(dx(z0))
   dx(div(z0, z1)) -> minus(div(dx(z0), z1), times(z0, div(dx(z1), exp(z1, two))))
   dx(ln(z0)) -> div(dx(z0), z0)
   dx(exp(z0, z1)) -> plus(times(z1, times(exp(z0, minus(z1, one)), dx(z0))), times(exp(z0, z1), times(ln(z0), dx(z1))))
Tuples:
   DX(z0) -> c
   DX(a) -> c1
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
S tuples:
   DX(z0) -> c
   DX(a) -> c1
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
K tuples:none
Defined Rule Symbols:   dx_1

Defined Pair Symbols:   DX_1

Compound Symbols:   c, c1, c2_2, c3_2, c4_2, c5_1, c6_2, c7_1, c8_2


----------------------------------------

(3) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   DX(z0) -> c
   DX(a) -> c1

----------------------------------------

(4)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   dx(z0) -> one
   dx(a) -> zero
   dx(plus(z0, z1)) -> plus(dx(z0), dx(z1))
   dx(times(z0, z1)) -> plus(times(z1, dx(z0)), times(z0, dx(z1)))
   dx(minus(z0, z1)) -> minus(dx(z0), dx(z1))
   dx(neg(z0)) -> neg(dx(z0))
   dx(div(z0, z1)) -> minus(div(dx(z0), z1), times(z0, div(dx(z1), exp(z1, two))))
   dx(ln(z0)) -> div(dx(z0), z0)
   dx(exp(z0, z1)) -> plus(times(z1, times(exp(z0, minus(z1, one)), dx(z0))), times(exp(z0, z1), times(ln(z0), dx(z1))))
Tuples:
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
S tuples:
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
K tuples:none
Defined Rule Symbols:   dx_1

Defined Pair Symbols:   DX_1

Compound Symbols:   c2_2, c3_2, c4_2, c5_1, c6_2, c7_1, c8_2


----------------------------------------

(5) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   dx(z0) -> one
   dx(a) -> zero
   dx(plus(z0, z1)) -> plus(dx(z0), dx(z1))
   dx(times(z0, z1)) -> plus(times(z1, dx(z0)), times(z0, dx(z1)))
   dx(minus(z0, z1)) -> minus(dx(z0), dx(z1))
   dx(neg(z0)) -> neg(dx(z0))
   dx(div(z0, z1)) -> minus(div(dx(z0), z1), times(z0, div(dx(z1), exp(z1, two))))
   dx(ln(z0)) -> div(dx(z0), z0)
   dx(exp(z0, z1)) -> plus(times(z1, times(exp(z0, minus(z1, one)), dx(z0))), times(exp(z0, z1), times(ln(z0), dx(z1))))

----------------------------------------

(6)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
S tuples:
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
K tuples:none
Defined Rule Symbols:none

Defined Pair Symbols:   DX_1

Compound Symbols:   c2_2, c3_2, c4_2, c5_1, c6_2, c7_1, c8_2


----------------------------------------

(7) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
We considered the (Usable) Rules:none
And the Tuples:
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(DX(x_1)) = x_1
   POL(c2(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1, x_2)) = x_1 + x_2
   POL(c4(x_1, x_2)) = x_1 + x_2
   POL(c5(x_1)) = x_1
   POL(c6(x_1, x_2)) = x_1 + x_2
   POL(c7(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(div(x_1, x_2)) = [1] + x_1 + x_2
   POL(exp(x_1, x_2)) = [1] + x_1 + x_2
   POL(ln(x_1)) = [1] + x_1
   POL(minus(x_1, x_2)) = [1] + x_1 + x_2
   POL(neg(x_1)) = [1] + x_1
   POL(plus(x_1, x_2)) = [1] + x_1 + x_2
   POL(times(x_1, x_2)) = [1] + x_1 + x_2

----------------------------------------

(8)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
S tuples:none
K tuples:
   DX(plus(z0, z1)) -> c2(DX(z0), DX(z1))
   DX(times(z0, z1)) -> c3(DX(z0), DX(z1))
   DX(minus(z0, z1)) -> c4(DX(z0), DX(z1))
   DX(neg(z0)) -> c5(DX(z0))
   DX(div(z0, z1)) -> c6(DX(z0), DX(z1))
   DX(ln(z0)) -> c7(DX(z0))
   DX(exp(z0, z1)) -> c8(DX(z0), DX(z1))
Defined Rule Symbols:none

Defined Pair Symbols:   DX_1

Compound Symbols:   c2_2, c3_2, c4_2, c5_1, c6_2, c7_1, c8_2


----------------------------------------

(9) SIsEmptyProof (BOTH BOUNDS(ID, ID))
The set S is empty
----------------------------------------

(10)
BOUNDS(1, 1)

----------------------------------------

(11) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(12)
Obligation:
The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   dx(X) -> one
   dx(a) -> zero
   dx(plus(ALPHA, BETA)) -> plus(dx(ALPHA), dx(BETA))
   dx(times(ALPHA, BETA)) -> plus(times(BETA, dx(ALPHA)), times(ALPHA, dx(BETA)))
   dx(minus(ALPHA, BETA)) -> minus(dx(ALPHA), dx(BETA))
   dx(neg(ALPHA)) -> neg(dx(ALPHA))
   dx(div(ALPHA, BETA)) -> minus(div(dx(ALPHA), BETA), times(ALPHA, div(dx(BETA), exp(BETA, two))))
   dx(ln(ALPHA)) -> div(dx(ALPHA), ALPHA)
   dx(exp(ALPHA, BETA)) -> plus(times(BETA, times(exp(ALPHA, minus(BETA, one)), dx(ALPHA))), times(exp(ALPHA, BETA), times(ln(ALPHA), dx(BETA))))

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(13) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(14)
Obligation:
Innermost TRS:
Rules:
dx(X) -> one
dx(a) -> zero
dx(plus(ALPHA, BETA)) -> plus(dx(ALPHA), dx(BETA))
dx(times(ALPHA, BETA)) -> plus(times(BETA, dx(ALPHA)), times(ALPHA, dx(BETA)))
dx(minus(ALPHA, BETA)) -> minus(dx(ALPHA), dx(BETA))
dx(neg(ALPHA)) -> neg(dx(ALPHA))
dx(div(ALPHA, BETA)) -> minus(div(dx(ALPHA), BETA), times(ALPHA, div(dx(BETA), exp(BETA, two))))
dx(ln(ALPHA)) -> div(dx(ALPHA), ALPHA)
dx(exp(ALPHA, BETA)) -> plus(times(BETA, times(exp(ALPHA, minus(BETA, one)), dx(ALPHA))), times(exp(ALPHA, BETA), times(ln(ALPHA), dx(BETA))))

Types:
dx :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
one :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
a :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
zero :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
plus :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
times :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
minus :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
neg :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
div :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
exp :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
two :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
ln :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
hole_one:a:zero:plus:times:minus:neg:div:two:exp:ln1_0 :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0 :: Nat -> one:a:zero:plus:times:minus:neg:div:two:exp:ln

----------------------------------------

(15) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
dx
----------------------------------------

(16)
Obligation:
Innermost TRS:
Rules:
dx(X) -> one
dx(a) -> zero
dx(plus(ALPHA, BETA)) -> plus(dx(ALPHA), dx(BETA))
dx(times(ALPHA, BETA)) -> plus(times(BETA, dx(ALPHA)), times(ALPHA, dx(BETA)))
dx(minus(ALPHA, BETA)) -> minus(dx(ALPHA), dx(BETA))
dx(neg(ALPHA)) -> neg(dx(ALPHA))
dx(div(ALPHA, BETA)) -> minus(div(dx(ALPHA), BETA), times(ALPHA, div(dx(BETA), exp(BETA, two))))
dx(ln(ALPHA)) -> div(dx(ALPHA), ALPHA)
dx(exp(ALPHA, BETA)) -> plus(times(BETA, times(exp(ALPHA, minus(BETA, one)), dx(ALPHA))), times(exp(ALPHA, BETA), times(ln(ALPHA), dx(BETA))))

Types:
dx :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
one :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
a :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
zero :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
plus :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
times :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
minus :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
neg :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
div :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
exp :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
two :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
ln :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
hole_one:a:zero:plus:times:minus:neg:div:two:exp:ln1_0 :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0 :: Nat -> one:a:zero:plus:times:minus:neg:div:two:exp:ln


Generator Equations:
gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(0) <=> a
gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(+(x, 1)) <=> plus(a, gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(x))


The following defined symbols remain to be analysed:
dx
----------------------------------------

(17) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
dx(gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(n4_0)) -> *3_0, rt in Omega(n4_0)

Induction Base:
dx(gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(0))

Induction Step:
dx(gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(+(n4_0, 1))) ->_R^Omega(1)
plus(dx(a), dx(gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(n4_0))) ->_R^Omega(1)
plus(one, dx(gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(n4_0))) ->_IH
plus(one, *3_0)

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(18)
Obligation:
Proved the lower bound n^1 for the following obligation:

Innermost TRS:
Rules:
dx(X) -> one
dx(a) -> zero
dx(plus(ALPHA, BETA)) -> plus(dx(ALPHA), dx(BETA))
dx(times(ALPHA, BETA)) -> plus(times(BETA, dx(ALPHA)), times(ALPHA, dx(BETA)))
dx(minus(ALPHA, BETA)) -> minus(dx(ALPHA), dx(BETA))
dx(neg(ALPHA)) -> neg(dx(ALPHA))
dx(div(ALPHA, BETA)) -> minus(div(dx(ALPHA), BETA), times(ALPHA, div(dx(BETA), exp(BETA, two))))
dx(ln(ALPHA)) -> div(dx(ALPHA), ALPHA)
dx(exp(ALPHA, BETA)) -> plus(times(BETA, times(exp(ALPHA, minus(BETA, one)), dx(ALPHA))), times(exp(ALPHA, BETA), times(ln(ALPHA), dx(BETA))))

Types:
dx :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
one :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
a :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
zero :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
plus :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
times :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
minus :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
neg :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
div :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
exp :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
two :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
ln :: one:a:zero:plus:times:minus:neg:div:two:exp:ln -> one:a:zero:plus:times:minus:neg:div:two:exp:ln
hole_one:a:zero:plus:times:minus:neg:div:two:exp:ln1_0 :: one:a:zero:plus:times:minus:neg:div:two:exp:ln
gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0 :: Nat -> one:a:zero:plus:times:minus:neg:div:two:exp:ln


Generator Equations:
gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(0) <=> a
gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(+(x, 1)) <=> plus(a, gen_one:a:zero:plus:times:minus:neg:div:two:exp:ln2_0(x))


The following defined symbols remain to be analysed:
dx
----------------------------------------

(19) LowerBoundPropagationProof (FINISHED)
Propagated lower bound.
----------------------------------------

(20)
BOUNDS(n^1, INF)