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


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


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


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

(0) CpxTRS
(1) NestedDefinedSymbolProof [UPPER BOUND(ID), 0 ms]
(2) CpxTRS
(3) NarrowingOnBasicTermsTerminatesProof [FINISHED, 0 ms]
(4) BOUNDS(1, 1)


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

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


The TRS R consists of the following rules:

   terms(N) -> cons(recip(sqr(N)), n__terms(s(N)))
   sqr(0) -> 0
   sqr(s(X)) -> s(n__add(sqr(activate(X)), dbl(activate(X))))
   dbl(0) -> 0
   dbl(s(X)) -> s(n__s(n__dbl(activate(X))))
   add(0, X) -> X
   add(s(X), Y) -> s(n__add(activate(X), Y))
   first(0, X) -> nil
   first(s(X), cons(Y, Z)) -> cons(Y, n__first(activate(X), activate(Z)))
   terms(X) -> n__terms(X)
   add(X1, X2) -> n__add(X1, X2)
   s(X) -> n__s(X)
   dbl(X) -> n__dbl(X)
   first(X1, X2) -> n__first(X1, X2)
   activate(n__terms(X)) -> terms(X)
   activate(n__add(X1, X2)) -> add(X1, X2)
   activate(n__s(X)) -> s(X)
   activate(n__dbl(X)) -> dbl(X)
   activate(n__first(X1, X2)) -> first(X1, X2)
   activate(X) -> X

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

(1) NestedDefinedSymbolProof (UPPER BOUND(ID))
The TRS does not nest defined symbols.
Hence, the left-hand sides of the following rules are not basic-reachable and can be removed:
sqr(s(X)) -> s(n__add(sqr(activate(X)), dbl(activate(X))))
dbl(s(X)) -> s(n__s(n__dbl(activate(X))))
add(s(X), Y) -> s(n__add(activate(X), Y))
first(s(X), cons(Y, Z)) -> cons(Y, n__first(activate(X), activate(Z)))

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

(2)
Obligation:
The Runtime Complexity (full) of the given CpxTRS could be proven to be BOUNDS(1, 1).


The TRS R consists of the following rules:

   terms(N) -> cons(recip(sqr(N)), n__terms(s(N)))
   sqr(0) -> 0
   dbl(0) -> 0
   add(0, X) -> X
   first(0, X) -> nil
   terms(X) -> n__terms(X)
   add(X1, X2) -> n__add(X1, X2)
   s(X) -> n__s(X)
   dbl(X) -> n__dbl(X)
   first(X1, X2) -> n__first(X1, X2)
   activate(n__terms(X)) -> terms(X)
   activate(n__add(X1, X2)) -> add(X1, X2)
   activate(n__s(X)) -> s(X)
   activate(n__dbl(X)) -> dbl(X)
   activate(n__first(X1, X2)) -> first(X1, X2)
   activate(X) -> X

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

(3) NarrowingOnBasicTermsTerminatesProof (FINISHED)
Constant runtime complexity proven by termination of constructor-based narrowing.

The maximal most general narrowing sequences give rise to the following rewrite sequences:

activate(n__first(x0, x1)) ->^* n__first(x0, x1)

activate(n__first(0, x0)) ->^* nil

activate(n__dbl(x0)) ->^* n__dbl(x0)

activate(n__dbl(0)) ->^* 0

activate(n__s(x0)) ->^* n__s(x0)

activate(n__add(x0, x1)) ->^* n__add(x0, x1)

activate(n__terms(x0)) ->^* n__terms(x0)

activate(n__terms(0)) ->^* cons(recip(0), n__terms(n__s(0)))

s(x0) ->^* n__s(x0)

first(x0, x1) ->^* n__first(x0, x1)

first(0, x0) ->^* nil

add(x0, x1) ->^* n__add(x0, x1)

dbl(x0) ->^* n__dbl(x0)

dbl(0) ->^* 0

sqr(0) ->^* 0

terms(x0) ->^* n__terms(x0)

terms(0) ->^* cons(recip(0), n__terms(n__s(0)))




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

(4)
BOUNDS(1, 1)