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


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


YES

Problem 1: 

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

Problem 1: 

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

Problem 1: 

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

Problem 1: 

Reduction Pair Processor:
-> Pairs:
 ACTIVATE(n__filter(X1:S,X2:S,X3:S)) -> FILTER(X1:S,X2:S,X3:S)
 ACTIVATE(n__sieve(X:S)) -> SIEVE(X:S)
 FILTER(cons(X:S,Y:S),0,M:S) -> ACTIVATE(Y:S)
 FILTER(cons(X:S,Y:S),s(N:S),M:S) -> ACTIVATE(Y:S)
 SIEVE(cons(0,Y:S)) -> ACTIVATE(Y:S)
 SIEVE(cons(s(N:S),Y:S)) -> ACTIVATE(Y:S)
 SIEVE(cons(s(N:S),Y:S)) -> FILTER(activate(Y:S),N:S,N:S)
-> Rules:
 activate(n__filter(X1:S,X2:S,X3:S)) -> filter(X1:S,X2:S,X3:S)
 activate(n__nats(X:S)) -> nats(X:S)
 activate(n__sieve(X:S)) -> sieve(X:S)
 activate(X:S) -> X:S
 filter(cons(X:S,Y:S),0,M:S) -> cons(0,n__filter(activate(Y:S),M:S,M:S))
 filter(cons(X:S,Y:S),s(N:S),M:S) -> cons(X:S,n__filter(activate(Y:S),N:S,M:S))
 filter(X1:S,X2:S,X3:S) -> n__filter(X1:S,X2:S,X3:S)
 nats(N:S) -> cons(N:S,n__nats(s(N:S)))
 nats(X:S) -> n__nats(X:S)
 sieve(cons(0,Y:S)) -> cons(0,n__sieve(activate(Y:S)))
 sieve(cons(s(N:S),Y:S)) -> cons(s(N:S),n__sieve(filter(activate(Y:S),N:S,N:S)))
 sieve(X:S) -> n__sieve(X:S)
 zprimes -> sieve(nats(s(s(0))))
-> Usable rules:
 activate(n__filter(X1:S,X2:S,X3:S)) -> filter(X1:S,X2:S,X3:S)
 activate(n__nats(X:S)) -> nats(X:S)
 activate(n__sieve(X:S)) -> sieve(X:S)
 activate(X:S) -> X:S
 filter(cons(X:S,Y:S),0,M:S) -> cons(0,n__filter(activate(Y:S),M:S,M:S))
 filter(cons(X:S,Y:S),s(N:S),M:S) -> cons(X:S,n__filter(activate(Y:S),N:S,M:S))
 filter(X1:S,X2:S,X3:S) -> n__filter(X1:S,X2:S,X3:S)
 nats(N:S) -> cons(N:S,n__nats(s(N:S)))
 nats(X:S) -> n__nats(X:S)
 sieve(cons(0,Y:S)) -> cons(0,n__sieve(activate(Y:S)))
 sieve(cons(s(N:S),Y:S)) -> cons(s(N:S),n__sieve(filter(activate(Y:S),N:S,N:S)))
 sieve(X:S) -> n__sieve(X:S)
->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
[FILTER](X1,X2,X3) = 2.X1
[SIEVE](X) = 2.X + 2

Problem 1: 

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

Problem 1: 

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

Problem 1: 

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

The problem is finite.