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


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


YES

Problem 1: 

(VAR M N X X1 X2 X3 Y)
(RULES
activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
activate(n__nats(X)) -> nats(X)
activate(n__sieve(X)) -> sieve(X)
activate(X) -> X
filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
filter(X1,X2,X3) -> n__filter(X1,X2,X3)
nats(N) -> cons(N,n__nats(s(N)))
nats(X) -> n__nats(X)
sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
sieve(X) -> n__sieve(X)
zprimes -> sieve(nats(s(s(0))))
)

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 ACTIVATE(n__filter(X1,X2,X3)) -> FILTER(X1,X2,X3)
 ACTIVATE(n__nats(X)) -> NATS(X)
 ACTIVATE(n__sieve(X)) -> SIEVE(X)
 FILTER(cons(X,Y),0,M) -> ACTIVATE(Y)
 FILTER(cons(X,Y),s(N),M) -> ACTIVATE(Y)
 SIEVE(cons(0,Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> FILTER(activate(Y),N,N)
 ZPRIMES -> NATS(s(s(0)))
 ZPRIMES -> SIEVE(nats(s(s(0))))
-> Rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
 zprimes -> sieve(nats(s(s(0))))

Problem 1: 

SCC Processor:
-> Pairs:
 ACTIVATE(n__filter(X1,X2,X3)) -> FILTER(X1,X2,X3)
 ACTIVATE(n__nats(X)) -> NATS(X)
 ACTIVATE(n__sieve(X)) -> SIEVE(X)
 FILTER(cons(X,Y),0,M) -> ACTIVATE(Y)
 FILTER(cons(X,Y),s(N),M) -> ACTIVATE(Y)
 SIEVE(cons(0,Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> FILTER(activate(Y),N,N)
 ZPRIMES -> NATS(s(s(0)))
 ZPRIMES -> SIEVE(nats(s(s(0))))
-> Rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
 zprimes -> sieve(nats(s(s(0))))
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVATE(n__filter(X1,X2,X3)) -> FILTER(X1,X2,X3)
 ACTIVATE(n__sieve(X)) -> SIEVE(X)
 FILTER(cons(X,Y),0,M) -> ACTIVATE(Y)
 FILTER(cons(X,Y),s(N),M) -> ACTIVATE(Y)
 SIEVE(cons(0,Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> FILTER(activate(Y),N,N)
->->-> Rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
 zprimes -> sieve(nats(s(s(0))))

Problem 1: 

Reduction Pair Processor:
-> Pairs:
 ACTIVATE(n__filter(X1,X2,X3)) -> FILTER(X1,X2,X3)
 ACTIVATE(n__sieve(X)) -> SIEVE(X)
 FILTER(cons(X,Y),0,M) -> ACTIVATE(Y)
 FILTER(cons(X,Y),s(N),M) -> ACTIVATE(Y)
 SIEVE(cons(0,Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> FILTER(activate(Y),N,N)
-> Rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
 zprimes -> sieve(nats(s(s(0))))
-> Usable rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[activate](X) = X
[filter](X1,X2,X3) = X1
[nats](X) = 0
[sieve](X) = 2.X + 2
[0] = 0
[cons](X1,X2) = X2
[n__filter](X1,X2,X3) = X1
[n__nats](X) = 0
[n__sieve](X) = 2.X + 2
[s](X) = 0
[ACTIVATE](X) = 2.X + 2
[FILTER](X1,X2,X3) = 2.X1 + 2
[SIEVE](X) = 2.X + 2

Problem 1: 

SCC Processor:
-> Pairs:
 ACTIVATE(n__filter(X1,X2,X3)) -> FILTER(X1,X2,X3)
 FILTER(cons(X,Y),0,M) -> ACTIVATE(Y)
 FILTER(cons(X,Y),s(N),M) -> ACTIVATE(Y)
 SIEVE(cons(0,Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> ACTIVATE(Y)
 SIEVE(cons(s(N),Y)) -> FILTER(activate(Y),N,N)
-> Rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
 zprimes -> sieve(nats(s(s(0))))
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 ACTIVATE(n__filter(X1,X2,X3)) -> FILTER(X1,X2,X3)
 FILTER(cons(X,Y),0,M) -> ACTIVATE(Y)
 FILTER(cons(X,Y),s(N),M) -> ACTIVATE(Y)
->->-> Rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
 zprimes -> sieve(nats(s(s(0))))

Problem 1: 

Subterm Processor:
-> Pairs:
 ACTIVATE(n__filter(X1,X2,X3)) -> FILTER(X1,X2,X3)
 FILTER(cons(X,Y),0,M) -> ACTIVATE(Y)
 FILTER(cons(X,Y),s(N),M) -> ACTIVATE(Y)
-> Rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
 zprimes -> sieve(nats(s(s(0))))
->Projection:
 pi(ACTIVATE) = 1
 pi(FILTER) = 1

Problem 1: 

SCC Processor:
-> Pairs:
 Empty
-> Rules:
 activate(n__filter(X1,X2,X3)) -> filter(X1,X2,X3)
 activate(n__nats(X)) -> nats(X)
 activate(n__sieve(X)) -> sieve(X)
 activate(X) -> X
 filter(cons(X,Y),0,M) -> cons(0,n__filter(activate(Y),M,M))
 filter(cons(X,Y),s(N),M) -> cons(X,n__filter(activate(Y),N,M))
 filter(X1,X2,X3) -> n__filter(X1,X2,X3)
 nats(N) -> cons(N,n__nats(s(N)))
 nats(X) -> n__nats(X)
 sieve(cons(0,Y)) -> cons(0,n__sieve(activate(Y)))
 sieve(cons(s(N),Y)) -> cons(s(N),n__sieve(filter(activate(Y),N,N)))
 sieve(X) -> n__sieve(X)
 zprimes -> sieve(nats(s(s(0))))
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.