LMPO
MAYBE
We consider the following Problem:
Strict Trs:
{ 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))
, 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)))
, nats(N) -> cons(N, n__nats(s(N)))
, zprimes() -> sieve(nats(s(s(0()))))
, filter(X1, X2, X3) -> n__filter(X1, X2, X3)
, sieve(X) -> n__sieve(X)
, nats(X) -> n__nats(X)
, activate(n__filter(X1, X2, X3)) -> filter(X1, X2, X3)
, activate(n__sieve(X)) -> sieve(X)
, activate(n__nats(X)) -> nats(X)
, activate(X) -> X}
StartTerms: basic terms
Strategy: innermost
Certificate: MAYBE
Proof:
The input cannot be shown compatible
Arrrr..
MPO
MAYBE
We consider the following Problem:
Strict Trs:
{ 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))
, 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)))
, nats(N) -> cons(N, n__nats(s(N)))
, zprimes() -> sieve(nats(s(s(0()))))
, filter(X1, X2, X3) -> n__filter(X1, X2, X3)
, sieve(X) -> n__sieve(X)
, nats(X) -> n__nats(X)
, activate(n__filter(X1, X2, X3)) -> filter(X1, X2, X3)
, activate(n__sieve(X)) -> sieve(X)
, activate(n__nats(X)) -> nats(X)
, activate(X) -> X}
StartTerms: basic terms
Strategy: innermost
Certificate: MAYBE
Proof:
The input cannot be shown compatible
Arrrr..
POP*
MAYBE
We consider the following Problem:
Strict Trs:
{ 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))
, 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)))
, nats(N) -> cons(N, n__nats(s(N)))
, zprimes() -> sieve(nats(s(s(0()))))
, filter(X1, X2, X3) -> n__filter(X1, X2, X3)
, sieve(X) -> n__sieve(X)
, nats(X) -> n__nats(X)
, activate(n__filter(X1, X2, X3)) -> filter(X1, X2, X3)
, activate(n__sieve(X)) -> sieve(X)
, activate(n__nats(X)) -> nats(X)
, activate(X) -> X}
StartTerms: basic terms
Strategy: innermost
Certificate: MAYBE
Proof:
The input cannot be shown compatible
Arrrr..
POP* (PS)
MAYBE
We consider the following Problem:
Strict Trs:
{ 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))
, 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)))
, nats(N) -> cons(N, n__nats(s(N)))
, zprimes() -> sieve(nats(s(s(0()))))
, filter(X1, X2, X3) -> n__filter(X1, X2, X3)
, sieve(X) -> n__sieve(X)
, nats(X) -> n__nats(X)
, activate(n__filter(X1, X2, X3)) -> filter(X1, X2, X3)
, activate(n__sieve(X)) -> sieve(X)
, activate(n__nats(X)) -> nats(X)
, activate(X) -> X}
StartTerms: basic terms
Strategy: innermost
Certificate: MAYBE
Proof:
The input cannot be shown compatible
Arrrr..
Small POP*
MAYBE
We consider the following Problem:
Strict Trs:
{ 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))
, 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)))
, nats(N) -> cons(N, n__nats(s(N)))
, zprimes() -> sieve(nats(s(s(0()))))
, filter(X1, X2, X3) -> n__filter(X1, X2, X3)
, sieve(X) -> n__sieve(X)
, nats(X) -> n__nats(X)
, activate(n__filter(X1, X2, X3)) -> filter(X1, X2, X3)
, activate(n__sieve(X)) -> sieve(X)
, activate(n__nats(X)) -> nats(X)
, activate(X) -> X}
StartTerms: basic terms
Strategy: innermost
Certificate: MAYBE
Proof:
The input cannot be shown compatible
Arrrr..
Small POP* (PS)
MAYBE
We consider the following Problem:
Strict Trs:
{ 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))
, 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)))
, nats(N) -> cons(N, n__nats(s(N)))
, zprimes() -> sieve(nats(s(s(0()))))
, filter(X1, X2, X3) -> n__filter(X1, X2, X3)
, sieve(X) -> n__sieve(X)
, nats(X) -> n__nats(X)
, activate(n__filter(X1, X2, X3)) -> filter(X1, X2, X3)
, activate(n__sieve(X)) -> sieve(X)
, activate(n__nats(X)) -> nats(X)
, activate(X) -> X}
StartTerms: basic terms
Strategy: innermost
Certificate: MAYBE
Proof:
The input cannot be shown compatible
Arrrr..