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


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


NO

We split firstr-order part and higher-order part, and do modular checking by a general modularity.

******** FO SN check ********
Check non-SN using NTI (Non-Termination Inference by Payet)

******** Computation rules ********
 (1)  f(g(X),s(0),Y) => f(g(s(0)),Y,g(X))
 (2)  g(s(U)) => s(g(U))
 (3)  g(0) => 0

forward process killed -- 22 rule(s) generated
forward+backward process killed -- 26 rule(s) generated

NO

let R be the TRS under consideration

f(g(_1),s(0),_2) -> f(g(s(0)),_2,g(_1)) is in elim_R(R)
let l0 be the left-hand side of this rule
p0 = 1.0 is a position in l0
we have l0|p0 = 0
g(0) -> 0 is in R
let r'0 be the right-hand side of this rule
theta0 = {} is a mgu of l0|p0 and r'0

==> f(g(_1),s(g(0)),_2) -> f(g(s(0)),_2,g(_1)) is in EU_R^1
let l1 be the left-hand side of this rule
p1 = 1 is a position in l1
we have l1|p1 = s(g(0))
g(s(_3)) -> s(g(_3)) is in R
let r'1 be the right-hand side of this rule
theta1 = {_3/0} is a mgu of l1|p1 and r'1

==> f(g(_1),g(s(0)),_2) -> f(g(s(0)),_2,g(_1)) is in EU_R^2
let l be the left-hand side and r be the right-hand side of this rule
let p = epsilon
let theta = {_1/s(0), _2/g(s(0))}
let theta' = {}
we have r|p = f(g(s(0)),_2,g(_1)) and
theta'(theta(l)) = theta(r|p)
so, theta(l) = f(g(s(0)),g(s(0)),g(s(0))) is non-terminating w.r.t. R

Termination disproved by the backward process
proof stopped at iteration i=2, depth k=3
15 rule(s) generated
>>NO


******** Signature ********
 0 : b
 cons : (d,e) -> e
 f : (b,b,b) -> a
 false : c
 filter : ((d -> c),e) -> e
 filter2 : (c,(d -> c),d,e) -> e
 g : b -> b
 map : ((d -> d),e) -> e
 nil : e
 s : b -> b
 true : c
******** Computation Rules ********
 (1)  f(g(X),s(0),Y) => f(g(s(0)),Y,g(X))
 (2)  g(s(U)) => s(g(U))
 (3)  g(0) => 0
 (4)  map(H,nil) => nil
 (5)  map(I,cons(P,X1)) => cons(I[P],map(I,X1))
 (6)  filter(Z1,nil) => nil
 (7)  filter(G1,cons(V1,W1)) => filter2(G1[V1],G1,V1,W1)
 (8)  filter2(true,J1,X2,Y2) => cons(X2,filter(J1,Y2))
 (9)  filter2(false,G2,V2,W2) => filter(G2,W2)

NO