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


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


NO
proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml
# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty


Outermost Termination of the given OTRS could be disproven:

(0) OTRS
(1) OutermostNonTerminationProof [COMPLETE, 1304 ms]
(2) NO


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

(0)
Obligation:
Term rewrite system R:
The TRS R consists of the following rules:

   and(tt, T) -> T
   isNatIList(IL) -> isNatList(activate(IL))
   isNat(n__0) -> tt
   isNat(n__s(N)) -> isNat(activate(N))
   isNat(n__length(L)) -> isNatList(activate(L))
   isNatIList(n__zeros) -> tt
   isNatIList(n__cons(N, IL)) -> and(isNat(activate(N)), isNatIList(activate(IL)))
   isNatList(n__nil) -> tt
   isNatList(n__cons(N, L)) -> and(isNat(activate(N)), isNatList(activate(L)))
   isNatList(n__take(N, IL)) -> and(isNat(activate(N)), isNatIList(activate(IL)))
   zeros -> cons(0, n__zeros)
   take(0, IL) -> uTake1(isNatIList(IL))
   uTake1(tt) -> nil
   take(s(M), cons(N, IL)) -> uTake2(and(isNat(M), and(isNat(N), isNatIList(activate(IL)))), M, N, activate(IL))
   uTake2(tt, M, N, IL) -> cons(activate(N), n__take(activate(M), activate(IL)))
   length(cons(N, L)) -> uLength(and(isNat(N), isNatList(activate(L))), activate(L))
   uLength(tt, L) -> s(length(activate(L)))
   0 -> n__0
   s(X) -> n__s(X)
   length(X) -> n__length(X)
   zeros -> n__zeros
   cons(X1, X2) -> n__cons(X1, X2)
   nil -> n__nil
   take(X1, X2) -> n__take(X1, X2)
   activate(n__0) -> 0
   activate(n__s(X)) -> s(activate(X))
   activate(n__length(X)) -> length(activate(X))
   activate(n__zeros) -> zeros
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2)
   activate(n__nil) -> nil
   activate(n__take(X1, X2)) -> take(activate(X1), activate(X2))
   activate(X) -> X



Outermost Strategy.

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

(1) OutermostNonTerminationProof (COMPLETE)
Term rewrite system R:
The TRS R consists of the following rules:

   and(tt, T) -> T
   isNatIList(IL) -> isNatList(activate(IL))
   isNat(n__0) -> tt
   isNat(n__s(N)) -> isNat(activate(N))
   isNat(n__length(L)) -> isNatList(activate(L))
   isNatIList(n__zeros) -> tt
   isNatIList(n__cons(N, IL)) -> and(isNat(activate(N)), isNatIList(activate(IL)))
   isNatList(n__nil) -> tt
   isNatList(n__cons(N, L)) -> and(isNat(activate(N)), isNatList(activate(L)))
   isNatList(n__take(N, IL)) -> and(isNat(activate(N)), isNatIList(activate(IL)))
   zeros -> cons(0, n__zeros)
   take(0, IL) -> uTake1(isNatIList(IL))
   uTake1(tt) -> nil
   take(s(M), cons(N, IL)) -> uTake2(and(isNat(M), and(isNat(N), isNatIList(activate(IL)))), M, N, activate(IL))
   uTake2(tt, M, N, IL) -> cons(activate(N), n__take(activate(M), activate(IL)))
   length(cons(N, L)) -> uLength(and(isNat(N), isNatList(activate(L))), activate(L))
   uLength(tt, L) -> s(length(activate(L)))
   0 -> n__0
   s(X) -> n__s(X)
   length(X) -> n__length(X)
   zeros -> n__zeros
   cons(X1, X2) -> n__cons(X1, X2)
   nil -> n__nil
   take(X1, X2) -> n__take(X1, X2)
   activate(n__0) -> 0
   activate(n__s(X)) -> s(activate(X))
   activate(n__length(X)) -> length(activate(X))
   activate(n__zeros) -> zeros
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2)
   activate(n__nil) -> nil
   activate(n__take(X1, X2)) -> take(activate(X1), activate(X2))
   activate(X) -> X



Outermost Strategy.

---------- Loop: ----------

isNatList(activate(n__zeros)) -> isNatList(zeros) with rule activate(n__zeros) -> zeros at position [0] and matcher [ ]

isNatList(zeros) -> isNatList(cons(0, n__zeros)) with rule zeros -> cons(0, n__zeros) at position [0] and matcher [ ]

isNatList(cons(0, n__zeros)) -> isNatList(n__cons(0, n__zeros)) with rule cons(X1, X2) -> n__cons(X1, X2) at position [0] and matcher [X1 / 0, X2 / n__zeros]

isNatList(n__cons(0, n__zeros)) -> and(isNat(activate(0)), isNatList(activate(n__zeros))) with rule isNatList(n__cons(N, L)) -> and(isNat(activate(N)), isNatList(activate(L))) at position [] and matcher [N / 0, L / n__zeros]

Now an instance of the first term with Matcher [ ] occurs in the last term at position [1].

Context: and(isNat(activate(0)), [])

We used [THIEMANN_LOOPS_UNDER_STRATEGIES] to show that this Loop is an Outermost-Loop.
----------------------------------------

(2)
NO