KILLED
proof of input_J1LGbzkjkV.trs
# AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished


The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).

(0) CpxTRS
(1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxTRS
(3) CpxTrsToCdtProof [BOTH BOUNDS(ID, ID), 0 ms]
(4) CdtProblem
    (5) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (6) CpxRelTRS
    (7) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
    (8) TRS for Loop Detection
    (9) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxRelTRS
        (11) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
        (12) typed CpxTrs
        (13) OrderProof [LOWER BOUND(ID), 19 ms]
        (14) typed CpxTrs
(15) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(16) CpxTRS
(17) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(18) CdtProblem
    (19) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (20) CdtProblem
    (21) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (22) CdtProblem
    (23) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (24) CdtProblem
    (25) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (26) CdtProblem
    (27) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (28) CdtProblem
    (29) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (30) CdtProblem
    (31) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (32) CpxRelTRS
        (33) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
        (34) CpxTRS
        (35) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (36) CpxWeightedTrs
            (37) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
            (38) CpxTypedWeightedTrs
            (39) CompletionProof [UPPER BOUND(ID), 0 ms]
            (40) CpxTypedWeightedCompleteTrs
                (41) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
                (42) CpxTypedWeightedCompleteTrs
                (43) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (44) CpxRNTS
                (45) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
                (46) CpxRNTS
            (47) CompletionProof [UPPER BOUND(ID), 0 ms]
            (48) CpxTypedWeightedCompleteTrs
                (49) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (50) CpxRNTS
    (51) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (52) CdtProblem
        (53) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (54) CdtProblem
        (55) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (56) CdtProblem
        (57) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (58) CdtProblem
        (59) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (60) CdtProblem
        (61) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (62) CdtProblem
        (63) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (64) CdtProblem
        (65) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (66) CdtProblem
        (67) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (68) CdtProblem
        (69) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (70) CdtProblem
        (71) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (72) CdtProblem
        (73) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (74) CdtProblem
        (75) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (76) CdtProblem
        (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (78) CdtProblem
        (79) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (80) CdtProblem
        (81) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (82) CdtProblem
        (83) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (84) CdtProblem
        (85) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (86) CdtProblem
        (87) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (88) CdtProblem
        (89) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (90) CdtProblem
        (91) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (92) CdtProblem
        (93) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (94) CdtProblem
        (95) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (96) CdtProblem
        (97) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (98) CdtProblem
        (99) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 5 ms]
        (100) CdtProblem
        (101) CdtRewritingProof [BOTH BOUNDS(ID, ID), 12 ms]
        (102) CdtProblem
        (103) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (104) CdtProblem
        (105) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (106) CdtProblem
        (107) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (108) CdtProblem
        (109) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (110) CdtProblem
        (111) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (112) CdtProblem
        (113) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 14.5 s]
        (114) CdtProblem
(115) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(116) CpxWeightedTrs
    (117) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CpxTypedWeightedTrs
    (119) CompletionProof [UPPER BOUND(ID), 0 ms]
    (120) CpxTypedWeightedCompleteTrs
        (121) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (122) CpxRNTS
    (123) CompletionProof [UPPER BOUND(ID), 0 ms]
    (124) CpxTypedWeightedCompleteTrs
        (125) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (126) CpxTypedWeightedCompleteTrs
        (127) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (128) CpxRNTS
        (129) InliningProof [UPPER BOUND(ID), 0 ms]
        (130) CpxRNTS
        (131) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (132) CpxRNTS


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

(0)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   primes -> sieve(from(s(s(0))))
   from(X) -> cons(X, from(s(X)))
   head(cons(X, Y)) -> X
   tail(cons(X, Y)) -> Y
   if(true, X, Y) -> X
   if(false, X, Y) -> Y
   filter(s(s(X)), cons(Y, Z)) -> if(divides(s(s(X)), Y), filter(s(s(X)), Z), cons(Y, filter(X, sieve(Y))))
   sieve(cons(X, Y)) -> cons(X, filter(X, sieve(Y)))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(1) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(2)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   primes -> sieve(from(s(s(0'))))
   from(X) -> cons(X, from(s(X)))
   head(cons(X, Y)) -> X
   tail(cons(X, Y)) -> Y
   if(true, X, Y) -> X
   if(false, X, Y) -> Y
   filter(s(s(X)), cons(Y, Z)) -> if(divides(s(s(X)), Y), filter(s(s(X)), Z), cons(Y, filter(X, sieve(Y))))
   sieve(cons(X, Y)) -> cons(X, filter(X, sieve(Y)))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(3) CpxTrsToCdtProof (BOTH BOUNDS(ID, ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(4)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
Tuples:
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
S tuples:
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
K tuples:none
Defined Rule Symbols:   primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   PRIMES, FROM_1, HEAD_1, TAIL_1, IF_3, FILTER_2, SIEVE_1

Compound Symbols:   c_2, c1_1, c2, c3, c4, c5, c6_2, c7_3, c8_2


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

(5) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(6)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))

The (relative) TRS S consists of the following rules:

   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Rewrite Strategy: INNERMOST
----------------------------------------

(7) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID))
Transformed a relative TRS into a decreasing-loop problem.
----------------------------------------

(8)
Obligation:
Analyzing the following TRS for decreasing loops:

The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))

The (relative) TRS S consists of the following rules:

   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Rewrite Strategy: INNERMOST
----------------------------------------

(9) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(10)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PRIMES -> c(SIEVE(from(s(s(0')))), FROM(s(s(0'))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))

The (relative) TRS S consists of the following rules:

   primes -> sieve(from(s(s(0'))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Rewrite Strategy: INNERMOST
----------------------------------------

(11) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Inferred types.
----------------------------------------

(12)
Obligation:
Innermost TRS:
Rules:
PRIMES -> c(SIEVE(from(s(s(0')))), FROM(s(s(0'))))
FROM(z0) -> c1(FROM(s(z0)))
HEAD(cons(z0, z1)) -> c2
TAIL(cons(z0, z1)) -> c3
IF(true, z0, z1) -> c4
IF(false, z0, z1) -> c5
FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
primes -> sieve(from(s(s(0'))))
from(z0) -> cons(z0, from(s(z0)))
head(cons(z0, z1)) -> z0
tail(cons(z0, z1)) -> z1
if(true, z0, z1) -> z0
if(false, z0, z1) -> z1
filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Types:
PRIMES :: c
c :: c8 -> c1 -> c
SIEVE :: 0':s:cons -> c8
from :: 0':s:cons -> 0':s:cons
s :: 0':s:cons -> 0':s:cons
0' :: 0':s:cons
FROM :: 0':s:cons -> c1
c1 :: c1 -> c1
HEAD :: 0':s:cons -> c2
cons :: 0':s:cons -> 0':s:cons -> 0':s:cons
c2 :: c2
TAIL :: 0':s:cons -> c3
c3 :: c3
IF :: true:false:divides -> 0':s:cons -> 0':s:cons -> c4:c5
true :: true:false:divides
c4 :: c4:c5
false :: true:false:divides
c5 :: c4:c5
FILTER :: 0':s:cons -> 0':s:cons -> c6:c7
c6 :: c4:c5 -> c6:c7 -> c6:c7
divides :: 0':s:cons -> 0':s:cons -> true:false:divides
filter :: 0':s:cons -> 0':s:cons -> 0':s:cons
sieve :: 0':s:cons -> 0':s:cons
c7 :: c4:c5 -> c6:c7 -> c8 -> c6:c7
c8 :: c6:c7 -> c8 -> c8
primes :: 0':s:cons
head :: 0':s:cons -> 0':s:cons
tail :: 0':s:cons -> 0':s:cons
if :: true:false:divides -> 0':s:cons -> 0':s:cons -> 0':s:cons
hole_c1_9 :: c
hole_c82_9 :: c8
hole_c13_9 :: c1
hole_0':s:cons4_9 :: 0':s:cons
hole_c25_9 :: c2
hole_c36_9 :: c3
hole_c4:c57_9 :: c4:c5
hole_true:false:divides8_9 :: true:false:divides
hole_c6:c79_9 :: c6:c7
gen_c810_9 :: Nat -> c8
gen_c111_9 :: Nat -> c1
gen_0':s:cons12_9 :: Nat -> 0':s:cons
gen_c6:c713_9 :: Nat -> c6:c7

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

(13) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
SIEVE, from, FROM, FILTER, filter, sieve

They will be analysed ascendingly in the following order:
SIEVE = FILTER
sieve < SIEVE
filter < FILTER
sieve < FILTER
filter = sieve

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

(14)
Obligation:
Innermost TRS:
Rules:
PRIMES -> c(SIEVE(from(s(s(0')))), FROM(s(s(0'))))
FROM(z0) -> c1(FROM(s(z0)))
HEAD(cons(z0, z1)) -> c2
TAIL(cons(z0, z1)) -> c3
IF(true, z0, z1) -> c4
IF(false, z0, z1) -> c5
FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
primes -> sieve(from(s(s(0'))))
from(z0) -> cons(z0, from(s(z0)))
head(cons(z0, z1)) -> z0
tail(cons(z0, z1)) -> z1
if(true, z0, z1) -> z0
if(false, z0, z1) -> z1
filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))

Types:
PRIMES :: c
c :: c8 -> c1 -> c
SIEVE :: 0':s:cons -> c8
from :: 0':s:cons -> 0':s:cons
s :: 0':s:cons -> 0':s:cons
0' :: 0':s:cons
FROM :: 0':s:cons -> c1
c1 :: c1 -> c1
HEAD :: 0':s:cons -> c2
cons :: 0':s:cons -> 0':s:cons -> 0':s:cons
c2 :: c2
TAIL :: 0':s:cons -> c3
c3 :: c3
IF :: true:false:divides -> 0':s:cons -> 0':s:cons -> c4:c5
true :: true:false:divides
c4 :: c4:c5
false :: true:false:divides
c5 :: c4:c5
FILTER :: 0':s:cons -> 0':s:cons -> c6:c7
c6 :: c4:c5 -> c6:c7 -> c6:c7
divides :: 0':s:cons -> 0':s:cons -> true:false:divides
filter :: 0':s:cons -> 0':s:cons -> 0':s:cons
sieve :: 0':s:cons -> 0':s:cons
c7 :: c4:c5 -> c6:c7 -> c8 -> c6:c7
c8 :: c6:c7 -> c8 -> c8
primes :: 0':s:cons
head :: 0':s:cons -> 0':s:cons
tail :: 0':s:cons -> 0':s:cons
if :: true:false:divides -> 0':s:cons -> 0':s:cons -> 0':s:cons
hole_c1_9 :: c
hole_c82_9 :: c8
hole_c13_9 :: c1
hole_0':s:cons4_9 :: 0':s:cons
hole_c25_9 :: c2
hole_c36_9 :: c3
hole_c4:c57_9 :: c4:c5
hole_true:false:divides8_9 :: true:false:divides
hole_c6:c79_9 :: c6:c7
gen_c810_9 :: Nat -> c8
gen_c111_9 :: Nat -> c1
gen_0':s:cons12_9 :: Nat -> 0':s:cons
gen_c6:c713_9 :: Nat -> c6:c7


Generator Equations:
gen_c810_9(0) <=> hole_c82_9
gen_c810_9(+(x, 1)) <=> c8(hole_c6:c79_9, gen_c810_9(x))
gen_c111_9(0) <=> hole_c13_9
gen_c111_9(+(x, 1)) <=> c1(gen_c111_9(x))
gen_0':s:cons12_9(0) <=> 0'
gen_0':s:cons12_9(+(x, 1)) <=> s(gen_0':s:cons12_9(x))
gen_c6:c713_9(0) <=> hole_c6:c79_9
gen_c6:c713_9(+(x, 1)) <=> c6(c4, gen_c6:c713_9(x))


The following defined symbols remain to be analysed:
from, SIEVE, FROM, FILTER, filter, sieve

They will be analysed ascendingly in the following order:
SIEVE = FILTER
sieve < SIEVE
filter < FILTER
sieve < FILTER
filter = sieve

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

(15) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(16)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   primes -> sieve(from(s(s(0))))
   from(X) -> cons(X, from(s(X)))
   head(cons(X, Y)) -> X
   tail(cons(X, Y)) -> Y
   if(true, X, Y) -> X
   if(false, X, Y) -> Y
   filter(s(s(X)), cons(Y, Z)) -> if(divides(s(s(X)), Y), filter(s(s(X)), Z), cons(Y, filter(X, sieve(Y))))
   sieve(cons(X, Y)) -> cons(X, filter(X, sieve(Y)))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(17) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(18)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
Tuples:
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
S tuples:
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(true, z0, z1) -> c4
   IF(false, z0, z1) -> c5
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
K tuples:none
Defined Rule Symbols:   primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   PRIMES, FROM_1, HEAD_1, TAIL_1, IF_3, FILTER_2, SIEVE_1

Compound Symbols:   c_2, c1_1, c2, c3, c4, c5, c6_2, c7_3, c8_2


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

(19) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 4 trailing nodes:
   HEAD(cons(z0, z1)) -> c2
   TAIL(cons(z0, z1)) -> c3
   IF(false, z0, z1) -> c5
   IF(true, z0, z1) -> c4

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

(20)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
Tuples:
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
S tuples:
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(IF(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))), FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
K tuples:none
Defined Rule Symbols:   primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   PRIMES, FROM_1, FILTER_2, SIEVE_1

Compound Symbols:   c_2, c1_1, c6_2, c7_3, c8_2


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

(21) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(22)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
Tuples:
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
S tuples:
   PRIMES -> c(SIEVE(from(s(s(0)))), FROM(s(s(0))))
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
K tuples:none
Defined Rule Symbols:   primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c_2, c1_1, c8_2, c6_1, c7_2


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

(23) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(24)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
   PRIMES -> c2(FROM(s(s(0))))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
   PRIMES -> c2(FROM(s(s(0))))
K tuples:none
Defined Rule Symbols:   primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   FROM_1, SIEVE_1, FILTER_2, PRIMES

Compound Symbols:   c1_1, c8_2, c6_1, c7_2, c2_1


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

(25) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   PRIMES -> c2(FROM(s(s(0))))

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

(26)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
K tuples:none
Defined Rule Symbols:   primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   FROM_1, SIEVE_1, FILTER_2, PRIMES

Compound Symbols:   c1_1, c8_2, c6_1, c7_2, c2_1


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

(27) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   PRIMES -> c2(SIEVE(from(s(s(0)))))

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

(28)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   primes -> sieve(from(s(s(0))))
   from(z0) -> cons(z0, from(s(z0)))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   primes, from_1, head_1, tail_1, if_3, filter_2, sieve_1

Defined Pair Symbols:   FROM_1, SIEVE_1, FILTER_2, PRIMES

Compound Symbols:   c1_1, c8_2, c6_1, c7_2, c2_1


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

(29) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   primes -> sieve(from(s(s(0))))
   head(cons(z0, z1)) -> z0
   tail(cons(z0, z1)) -> z1
   if(true, z0, z1) -> z0
   if(false, z0, z1) -> z1

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

(30)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM_1, SIEVE_1, FILTER_2, PRIMES

Compound Symbols:   c1_1, c8_2, c6_1, c7_2, c2_1


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

(31) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(32)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))

The (relative) TRS S consists of the following rules:

   PRIMES -> c2(SIEVE(from(s(s(0)))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))

Rewrite Strategy: INNERMOST
----------------------------------------

(33) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(34)
Obligation:
The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   FROM(z0) -> c1(FROM(s(z0)))
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(35) RelTrsToWeightedTrsProof (BOTH BOUNDS(ID, ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(36)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   FROM(z0) -> c1(FROM(s(z0))) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   PRIMES -> c2(SIEVE(from(s(s(0))))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1))) [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]

Rewrite Strategy: INNERMOST
----------------------------------------

(37) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(38)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   FROM(z0) -> c1(FROM(s(z0))) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   PRIMES -> c2(SIEVE(from(s(s(0))))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1))) [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]

The TRS has the following type information:
FROM :: s:cons:0:if -> c1
c1 :: c1 -> c1
s :: s:cons:0:if -> s:cons:0:if
SIEVE :: s:cons:0:if -> c8
cons :: s:cons:0:if -> s:cons:0:if -> s:cons:0:if
c8 :: c6:c7 -> c8 -> c8
FILTER :: s:cons:0:if -> s:cons:0:if -> c6:c7
sieve :: s:cons:0:if -> s:cons:0:if
c6 :: c6:c7 -> c6:c7
c7 :: c6:c7 -> c8 -> c6:c7
PRIMES :: c2
c2 :: c8 -> c2
from :: s:cons:0:if -> s:cons:0:if
0 :: s:cons:0:if
filter :: s:cons:0:if -> s:cons:0:if -> s:cons:0:if
if :: divides -> s:cons:0:if -> s:cons:0:if -> s:cons:0:if
divides :: s:cons:0:if -> s:cons:0:if -> divides

Rewrite Strategy: INNERMOST
----------------------------------------

(39) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   FROM_1
   SIEVE_1
   FILTER_2

(c) The following functions are completely defined:

   PRIMES
   sieve_1
   filter_2
   from_1

Due to the following rules being added:

   PRIMES -> const3 [0]
   sieve(v0) -> 0 [0]
   filter(v0, v1) -> 0 [0]
   from(v0) -> 0 [0]

And the following fresh constants:    const3, const, const1, const2, const4

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

(40)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   FROM(z0) -> c1(FROM(s(z0))) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   PRIMES -> c2(SIEVE(from(s(s(0))))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1))) [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]
   PRIMES -> const3 [0]
   sieve(v0) -> 0 [0]
   filter(v0, v1) -> 0 [0]
   from(v0) -> 0 [0]

The TRS has the following type information:
FROM :: s:cons:0:if -> c1
c1 :: c1 -> c1
s :: s:cons:0:if -> s:cons:0:if
SIEVE :: s:cons:0:if -> c8
cons :: s:cons:0:if -> s:cons:0:if -> s:cons:0:if
c8 :: c6:c7 -> c8 -> c8
FILTER :: s:cons:0:if -> s:cons:0:if -> c6:c7
sieve :: s:cons:0:if -> s:cons:0:if
c6 :: c6:c7 -> c6:c7
c7 :: c6:c7 -> c8 -> c6:c7
PRIMES :: c2:const3
c2 :: c8 -> c2:const3
from :: s:cons:0:if -> s:cons:0:if
0 :: s:cons:0:if
filter :: s:cons:0:if -> s:cons:0:if -> s:cons:0:if
if :: divides -> s:cons:0:if -> s:cons:0:if -> s:cons:0:if
divides :: s:cons:0:if -> s:cons:0:if -> divides
const3 :: c2:const3
const :: c1
const1 :: c8
const2 :: c6:c7
const4 :: divides

Rewrite Strategy: INNERMOST
----------------------------------------

(41) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(42)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   FROM(z0) -> c1(FROM(s(z0))) [1]
   SIEVE(cons(z0, cons(z0', z1'))) -> c8(FILTER(z0, cons(z0', filter(z0', sieve(z1')))), SIEVE(cons(z0', z1'))) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, 0), SIEVE(z1)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(cons(z0'', z1''), z2)) -> c7(FILTER(z0, cons(z0'', filter(z0'', sieve(z1'')))), SIEVE(cons(z0'', z1''))) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, 0), SIEVE(z1)) [1]
   PRIMES -> c2(SIEVE(cons(s(s(0)), from(s(s(s(0))))))) [0]
   PRIMES -> c2(SIEVE(0)) [0]
   sieve(cons(z0, cons(z01, z11))) -> cons(z0, filter(z0, cons(z01, filter(z01, sieve(z11))))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, 0)) [0]
   filter(s(s(z0)), cons(cons(z02, z12), z2)) -> if(divides(s(s(z0)), cons(z02, z12)), filter(s(s(z0)), z2), cons(cons(z02, z12), filter(z0, cons(z02, filter(z02, sieve(z12)))))) [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, 0))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]
   PRIMES -> const3 [0]
   sieve(v0) -> 0 [0]
   filter(v0, v1) -> 0 [0]
   from(v0) -> 0 [0]

The TRS has the following type information:
FROM :: s:cons:0:if -> c1
c1 :: c1 -> c1
s :: s:cons:0:if -> s:cons:0:if
SIEVE :: s:cons:0:if -> c8
cons :: s:cons:0:if -> s:cons:0:if -> s:cons:0:if
c8 :: c6:c7 -> c8 -> c8
FILTER :: s:cons:0:if -> s:cons:0:if -> c6:c7
sieve :: s:cons:0:if -> s:cons:0:if
c6 :: c6:c7 -> c6:c7
c7 :: c6:c7 -> c8 -> c6:c7
PRIMES :: c2:const3
c2 :: c8 -> c2:const3
from :: s:cons:0:if -> s:cons:0:if
0 :: s:cons:0:if
filter :: s:cons:0:if -> s:cons:0:if -> s:cons:0:if
if :: divides -> s:cons:0:if -> s:cons:0:if -> s:cons:0:if
divides :: s:cons:0:if -> s:cons:0:if -> divides
const3 :: c2:const3
const :: c1
const1 :: c8
const2 :: c6:c7
const4 :: divides

Rewrite Strategy: INNERMOST
----------------------------------------

(43) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   const3 => 0
   const => 0
   const1 => 0
   const2 => 0
   const4 => 0

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

(44)
Obligation:
Complexity RNTS consisting of the following rules:

   FILTER(z, z') -{ 1 }-> 1 + FILTER(1 + (1 + z0), z2) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + FILTER(z0, 1 + z0'' + filter(z0'', sieve(z1''))) + SIEVE(1 + z0'' + z1'') :|: z' = 1 + (1 + z0'' + z1'') + z2, z0 >= 0, z0'' >= 0, z = 1 + (1 + z0), z2 >= 0, z1'' >= 0
   FROM(z) -{ 1 }-> 1 + FROM(1 + z0) :|: z = z0, z0 >= 0
   PRIMES -{ 0 }-> 0 :|: 
   PRIMES -{ 0 }-> 1 + SIEVE(0) :|: 
   PRIMES -{ 0 }-> 1 + SIEVE(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) :|: 
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 1 + z0' + filter(z0', sieve(z1'))) + SIEVE(1 + z0' + z1') :|: z = 1 + z0 + (1 + z0' + z1'), z0' >= 0, z1' >= 0, z0 >= 0
   filter(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   filter(z, z') -{ 0 }-> 1 + (1 + (1 + (1 + z0)) + z1) + filter(1 + (1 + z0), z2) + (1 + z1 + filter(z0, 0)) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   filter(z, z') -{ 0 }-> 1 + (1 + (1 + (1 + z0)) + (1 + z02 + z12)) + filter(1 + (1 + z0), z2) + (1 + (1 + z02 + z12) + filter(z0, 1 + z02 + filter(z02, sieve(z12)))) :|: z02 >= 0, z0 >= 0, z12 >= 0, z' = 1 + (1 + z02 + z12) + z2, z = 1 + (1 + z0), z2 >= 0
   from(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   from(z) -{ 0 }-> 1 + z0 + from(1 + z0) :|: z = z0, z0 >= 0
   sieve(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 1 + z01 + filter(z01, sieve(z11))) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)


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

(45) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(46)
Obligation:
Complexity RNTS consisting of the following rules:

   FILTER(z, z') -{ 1 }-> 1 + FILTER(1 + (1 + (z - 2)), z2) :|: z1 >= 0, z' = 1 + z1 + z2, z - 2 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + FILTER(z - 2, 0) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + z2, z - 2 >= 0, z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + FILTER(z - 2, 1 + z0'' + filter(z0'', sieve(z1''))) + SIEVE(1 + z0'' + z1'') :|: z' = 1 + (1 + z0'' + z1'') + z2, z - 2 >= 0, z0'' >= 0, z2 >= 0, z1'' >= 0
   FROM(z) -{ 1 }-> 1 + FROM(1 + z) :|: z >= 0
   PRIMES -{ 0 }-> 0 :|: 
   PRIMES -{ 0 }-> 1 + SIEVE(0) :|: 
   PRIMES -{ 0 }-> 1 + SIEVE(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) :|: 
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 0) + SIEVE(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, 1 + z0' + filter(z0', sieve(z1'))) + SIEVE(1 + z0' + z1') :|: z = 1 + z0 + (1 + z0' + z1'), z0' >= 0, z1' >= 0, z0 >= 0
   filter(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   filter(z, z') -{ 0 }-> 1 + (1 + (1 + (1 + (z - 2))) + z1) + filter(1 + (1 + (z - 2)), z2) + (1 + z1 + filter(z - 2, 0)) :|: z1 >= 0, z' = 1 + z1 + z2, z - 2 >= 0, z2 >= 0
   filter(z, z') -{ 0 }-> 1 + (1 + (1 + (1 + (z - 2))) + (1 + z02 + z12)) + filter(1 + (1 + (z - 2)), z2) + (1 + (1 + z02 + z12) + filter(z - 2, 1 + z02 + filter(z02, sieve(z12)))) :|: z02 >= 0, z - 2 >= 0, z12 >= 0, z' = 1 + (1 + z02 + z12) + z2, z2 >= 0
   from(z) -{ 0 }-> 0 :|: z >= 0
   from(z) -{ 0 }-> 1 + z + from(1 + z) :|: z >= 0
   sieve(z) -{ 0 }-> 0 :|: z >= 0
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, 1 + z01 + filter(z01, sieve(z11))) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)


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

(47) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:

   PRIMES -> null_PRIMES [0]
   sieve(v0) -> null_sieve [0]
   filter(v0, v1) -> null_filter [0]
   from(v0) -> null_from [0]
   SIEVE(v0) -> null_SIEVE [0]
   FILTER(v0, v1) -> null_FILTER [0]

And the following fresh constants:    null_PRIMES, null_sieve, null_filter, null_from, null_SIEVE, null_FILTER, const, const1

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

(48)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   FROM(z0) -> c1(FROM(s(z0))) [1]
   SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2)) [1]
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1)) [1]
   PRIMES -> c2(SIEVE(from(s(s(0))))) [0]
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1))) [0]
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1)))) [0]
   from(z0) -> cons(z0, from(s(z0))) [0]
   PRIMES -> null_PRIMES [0]
   sieve(v0) -> null_sieve [0]
   filter(v0, v1) -> null_filter [0]
   from(v0) -> null_from [0]
   SIEVE(v0) -> null_SIEVE [0]
   FILTER(v0, v1) -> null_FILTER [0]

The TRS has the following type information:
FROM :: s:cons:0:if:null_sieve:null_filter:null_from -> c1
c1 :: c1 -> c1
s :: s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from
SIEVE :: s:cons:0:if:null_sieve:null_filter:null_from -> c8:null_SIEVE
cons :: s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from
c8 :: c6:c7:null_FILTER -> c8:null_SIEVE -> c8:null_SIEVE
FILTER :: s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from -> c6:c7:null_FILTER
sieve :: s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from
c6 :: c6:c7:null_FILTER -> c6:c7:null_FILTER
c7 :: c6:c7:null_FILTER -> c8:null_SIEVE -> c6:c7:null_FILTER
PRIMES :: c2:null_PRIMES
c2 :: c8:null_SIEVE -> c2:null_PRIMES
from :: s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from
0 :: s:cons:0:if:null_sieve:null_filter:null_from
filter :: s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from
if :: divides -> s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from
divides :: s:cons:0:if:null_sieve:null_filter:null_from -> s:cons:0:if:null_sieve:null_filter:null_from -> divides
null_PRIMES :: c2:null_PRIMES
null_sieve :: s:cons:0:if:null_sieve:null_filter:null_from
null_filter :: s:cons:0:if:null_sieve:null_filter:null_from
null_from :: s:cons:0:if:null_sieve:null_filter:null_from
null_SIEVE :: c8:null_SIEVE
null_FILTER :: c6:c7:null_FILTER
const :: c1
const1 :: divides

Rewrite Strategy: INNERMOST
----------------------------------------

(49) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   null_PRIMES => 0
   null_sieve => 0
   null_filter => 0
   null_from => 0
   null_SIEVE => 0
   null_FILTER => 0
   const => 0
   const1 => 0

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

(50)
Obligation:
Complexity RNTS consisting of the following rules:

   FILTER(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   FILTER(z, z') -{ 1 }-> 1 + FILTER(1 + (1 + z0), z2) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FILTER(z, z') -{ 1 }-> 1 + FILTER(z0, sieve(z1)) + SIEVE(z1) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   FROM(z) -{ 1 }-> 1 + FROM(1 + z0) :|: z = z0, z0 >= 0
   PRIMES -{ 0 }-> 0 :|: 
   PRIMES -{ 0 }-> 1 + SIEVE(from(1 + (1 + 0))) :|: 
   SIEVE(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   SIEVE(z) -{ 1 }-> 1 + FILTER(z0, sieve(z1)) + SIEVE(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   filter(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   filter(z, z') -{ 0 }-> 1 + (1 + (1 + (1 + z0)) + z1) + filter(1 + (1 + z0), z2) + (1 + z1 + filter(z0, sieve(z1))) :|: z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z = 1 + (1 + z0), z2 >= 0
   from(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   from(z) -{ 0 }-> 1 + z0 + from(1 + z0) :|: z = z0, z0 >= 0
   sieve(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   sieve(z) -{ 0 }-> 1 + z0 + filter(z0, sieve(z1)) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1

Only complete derivations are relevant for the runtime complexity.

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

(51) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SIEVE(cons(z0, z1)) -> c8(FILTER(z0, sieve(z1)), SIEVE(z1)) by 
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))

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

(52)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM_1, FILTER_2, PRIMES, SIEVE_1

Compound Symbols:   c1_1, c6_1, c7_2, c2_1, c8_2


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

(53) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER(s(s(z0)), cons(z1, z2)) -> c7(FILTER(z0, sieve(z1)), SIEVE(z1)) by 
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))

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

(54)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   PRIMES -> c2(SIEVE(from(s(s(0)))))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM_1, FILTER_2, PRIMES, SIEVE_1

Compound Symbols:   c1_1, c6_1, c2_1, c8_2, c7_2


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

(55) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace PRIMES -> c2(SIEVE(from(s(s(0))))) by 
   PRIMES -> c2(SIEVE(cons(s(s(0)), from(s(s(s(0)))))))

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

(56)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), from(s(s(s(0)))))))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM_1, FILTER_2, SIEVE_1, PRIMES

Compound Symbols:   c1_1, c6_1, c8_2, c7_2, c2_1


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

(57) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace PRIMES -> c2(SIEVE(cons(s(s(0)), from(s(s(s(0))))))) by 
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))

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

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0)))))))))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM_1, FILTER_2, SIEVE_1, PRIMES

Compound Symbols:   c1_1, c6_1, c8_2, c7_2, c2_1


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

(59) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), from(s(s(s(s(0))))))))) by PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
----------------------------------------

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0)))))))))))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM_1, FILTER_2, SIEVE_1, PRIMES

Compound Symbols:   c1_1, c6_1, c8_2, c7_2, c2_1


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

(61) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), from(s(s(s(s(s(0))))))))))) by PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
----------------------------------------

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
S tuples:
   FROM(z0) -> c1(FROM(s(z0)))
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FROM_1, FILTER_2, SIEVE_1, PRIMES

Compound Symbols:   c1_1, c6_1, c8_2, c7_2, c2_1


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

(63) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace FROM(z0) -> c1(FROM(s(z0))) by 
   FROM(s(x0)) -> c1(FROM(s(s(x0))))

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

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(x0)) -> c1(FROM(s(s(x0))))
S tuples:
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FROM(s(x0)) -> c1(FROM(s(s(x0))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER_2, SIEVE_1, PRIMES, FROM_1

Compound Symbols:   c6_1, c8_2, c7_2, c2_1, c1_1


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

(65) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace FROM(s(x0)) -> c1(FROM(s(s(x0)))) by 
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))

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

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
S tuples:
   FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2))
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER_2, SIEVE_1, PRIMES, FROM_1

Compound Symbols:   c6_1, c8_2, c7_2, c2_1, c1_1


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

(67) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER(s(s(z0)), cons(z1, z2)) -> c6(FILTER(s(s(z0)), z2)) by 
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
S tuples:
   SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   SIEVE_1, FILTER_2, PRIMES, FROM_1

Compound Symbols:   c8_2, c7_2, c2_1, c1_1, c6_1


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

(69) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SIEVE(cons(x0, cons(z0, z1))) -> c8(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1))) by 
   SIEVE(cons(z0, cons(z1, cons(y1, y2)))) -> c8(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE(cons(z1, cons(y1, y2))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(z0, cons(z1, cons(y1, y2)))) -> c8(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE(cons(z1, cons(y1, y2))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
S tuples:
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(z0, cons(z1, cons(y1, y2)))) -> c8(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE(cons(z1, cons(y1, y2))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER_2, PRIMES, FROM_1, SIEVE_1

Compound Symbols:   c7_2, c2_1, c1_1, c6_1, c8_2


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

(71) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SIEVE(cons(z0, cons(z1, cons(y1, y2)))) -> c8(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, y2))))), SIEVE(cons(z1, cons(y1, y2)))) by 
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
S tuples:
   FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1)))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   FILTER_2, PRIMES, FROM_1, SIEVE_1

Compound Symbols:   c7_2, c2_1, c1_1, c6_1, c8_2


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

(73) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER(s(s(x0)), cons(cons(z0, z1), x2)) -> c7(FILTER(x0, cons(z0, filter(z0, sieve(z1)))), SIEVE(cons(z0, z1))) by 
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c7(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE(cons(s(s(y0)), cons(y1, y2))))
   FILTER(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c7(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE(cons(z1, cons(y1, cons(y2, y3)))))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c7(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE(cons(s(s(y0)), cons(y1, y2))))
   FILTER(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c7(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE(cons(z1, cons(y1, cons(y2, y3)))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c7(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE(cons(s(s(y0)), cons(y1, y2))))
   FILTER(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c7(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE(cons(z1, cons(y1, cons(y2, y3)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, FILTER_2, SIEVE_1

Compound Symbols:   c2_1, c1_1, c6_1, c8_2, c7_2


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

(75) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(y1, y2)), z3)) -> c7(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), sieve(cons(y1, y2))))), SIEVE(cons(s(s(y0)), cons(y1, y2)))) by 
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c7(FILTER(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(s(s(x1)), cons(z0, z1))))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c7(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c7(FILTER(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(s(s(x1)), cons(z0, z1))))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c7(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE(cons(z1, cons(y1, cons(y2, y3)))))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c7(FILTER(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(s(s(x1)), cons(z0, z1))))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, FILTER_2, SIEVE_1

Compound Symbols:   c2_1, c1_1, c6_1, c8_2, c7_2, c7_1


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

(77) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FILTER(s(s(z0)), cons(cons(z1, cons(y1, cons(y2, y3))), z3)) -> c7(FILTER(z0, cons(z1, filter(z1, sieve(cons(y1, cons(y2, y3)))))), SIEVE(cons(z1, cons(y1, cons(y2, y3))))) by 
   FILTER(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c7(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c7(FILTER(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(s(s(x1)), cons(z0, z1))))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c7(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c7(FILTER(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(s(s(x1)), cons(z0, z1))))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c7(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, FILTER_2, SIEVE_1

Compound Symbols:   c2_1, c1_1, c6_1, c8_2, c7_2, c7_1


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

(79) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(z0, z1)), x4)) -> c7(FILTER(x0, cons(s(s(x1)), filter(s(s(x1)), cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(s(s(x1)), cons(z0, z1)))) by FILTER(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c7(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, z3))))
----------------------------------------

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c7(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c7(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, z3))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c7(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(s(s(z1)), cons(z2, z3)), z4)) -> c7(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, z3))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, FILTER_2, SIEVE_1

Compound Symbols:   c2_1, c1_1, c6_1, c8_2, c7_2, c7_1


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

(81) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c7(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c7(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE(cons(x1, cons(z0, cons(x3, x4)))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, FILTER_2, SIEVE_1

Compound Symbols:   c2_1, c1_1, c6_1, c8_2, c7_2, c7_1


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

(83) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER(s(s(x0)), cons(cons(x1, cons(z0, cons(x3, x4))), x5)) -> c7(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(cons(x3, x4))))))), SIEVE(cons(x1, cons(z0, cons(x3, x4))))) by FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
----------------------------------------

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, FILTER_2, SIEVE_1

Compound Symbols:   c2_1, c1_1, c6_1, c8_2, c7_2, c7_1


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

(85) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER(s(s(z0)), cons(z1, cons(y1, y2))) -> c6(FILTER(s(s(z0)), cons(y1, y2))) by 
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3)))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, FILTER_2, SIEVE_1

Compound Symbols:   c2_1, c1_1, c6_1, c8_2, c7_2, c7_1


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

(87) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER(s(s(z0)), cons(z1, cons(cons(y1, y2), y3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, y2), y3))) by 
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), z4))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), z4)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z4))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z4)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, cons(y2, cons(y3, y4))), z4))) -> c6(FILTER(s(s(z0)), cons(cons(z2, cons(y2, cons(y3, y4))), z4)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1


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

(89) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SIEVE(cons(x0, cons(x1, cons(z0, z1)))) -> c8(FILTER(x0, cons(x1, filter(x1, cons(z0, filter(z0, sieve(z1)))))), SIEVE(cons(x1, cons(z0, z1)))) by 
   SIEVE(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c8(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(s(s(y0)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c8(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(s(s(y0)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c8(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(s(s(y0)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1


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

(91) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace SIEVE(cons(z0, cons(s(s(y0)), cons(z2, z3)))) -> c8(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(s(s(y0)), cons(z2, z3)))) by SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, z3))))
----------------------------------------

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, z3))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, sieve(z3))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, z3))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1


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

(93) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE(cons(z1, cons(z2, cons(y2, y3)))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(95) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace SIEVE(cons(z0, cons(z1, cons(z2, cons(y2, y3))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, sieve(cons(y2, y3))))))), SIEVE(cons(z1, cons(z2, cons(y2, y3))))) by SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
----------------------------------------

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(97) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER(s(s(x0)), cons(cons(x1, cons(x2, cons(x3, x4))), x5)) -> c7(SIEVE(cons(x1, cons(x2, cons(x3, x4))))) by 
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(99) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4))))) by 
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(101) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(y0)), filter(s(s(y0)), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4))))) by FILTER(s(s(z0)), cons(cons(s(s(z1)), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, cons(z3, filter(z3, sieve(z4))))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, cons(z3, z4)))))
----------------------------------------

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(z0)), cons(cons(s(s(z1)), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, cons(z3, filter(z3, sieve(z4))))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, cons(z3, z4)))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(z0)), cons(cons(s(s(z1)), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(z1)), if(divides(s(s(z1)), z2), filter(s(s(z1)), filter(z2, cons(z3, filter(z3, sieve(z4))))), cons(z2, filter(z1, sieve(z2)))))), SIEVE(cons(s(s(z1)), cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(103) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(105) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(y0)))), filter(s(s(s(s(y0)))), cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))))) by FILTER(s(s(z0)), cons(cons(s(s(s(s(z1)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(z1)))), if(divides(s(s(s(s(z1)))), z2), filter(s(s(s(s(z1)))), filter(z2, cons(z3, filter(z3, sieve(z4))))), cons(z2, filter(s(s(z1)), sieve(z2)))))), SIEVE(cons(s(s(s(s(z1)))), cons(z2, cons(z3, z4)))))
----------------------------------------

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(z1)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(z1)))), if(divides(s(s(s(s(z1)))), z2), filter(s(s(s(s(z1)))), filter(z2, cons(z3, filter(z3, sieve(z4))))), cons(z2, filter(s(s(z1)), sieve(z2)))))), SIEVE(cons(s(s(s(s(z1)))), cons(z2, cons(z3, z4)))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(z1)))), cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(s(s(s(s(z1)))), if(divides(s(s(s(s(z1)))), z2), filter(s(s(s(s(z1)))), filter(z2, cons(z3, filter(z3, sieve(z4))))), cons(z2, filter(s(s(z1)), sieve(z2)))))), SIEVE(cons(s(s(s(s(z1)))), cons(z2, cons(z3, z4)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(107) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(109) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(y1)), filter(s(s(y1)), cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4))))) by FILTER(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(z2)), if(divides(s(s(z2)), z3), filter(s(s(z2)), filter(z3, sieve(z4))), cons(z3, filter(z2, sieve(z3)))))))), SIEVE(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
----------------------------------------

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(z2)), if(divides(s(s(z2)), z3), filter(s(s(z2)), filter(z3, sieve(z4))), cons(z3, filter(z2, sieve(z3)))))))), SIEVE(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(z2)), if(divides(s(s(z2)), z3), filter(s(s(z2)), filter(z3, sieve(z4))), cons(z3, filter(z2, sieve(z3)))))))), SIEVE(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(111) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(cons(y3, y4))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4)))))) by FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, cons(z4, filter(z4, sieve(z5)))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
----------------------------------------

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(z2)), if(divides(s(s(z2)), z3), filter(s(s(z2)), filter(z3, sieve(z4))), cons(z3, filter(z2, sieve(z3)))))))), SIEVE(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, cons(z4, filter(z4, sieve(z5)))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(z2)), if(divides(s(s(z2)), z3), filter(s(s(z2)), filter(z3, sieve(z4))), cons(z3, filter(z2, sieve(z3)))))))), SIEVE(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, cons(z4, filter(z4, sieve(z5)))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(113) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
We considered the (Usable) Rules:
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
And the Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(z2)), if(divides(s(s(z2)), z3), filter(s(s(z2)), filter(z3, sieve(z4))), cons(z3, filter(z2, sieve(z3)))))))), SIEVE(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, cons(z4, filter(z4, sieve(z5)))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
The order we found is given by the following interpretation:

Matrix interpretation [MATRO]:

Non-tuple symbols: 
<<<
 M( s_1(x_1) ) =  	[[0], [0]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1
>>>

<<<
 M( filter_2(x_1, x_2) ) =  	[[0], [0]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1 	+ 	[[0, 0], [0, 0]] 	* 	x_2
>>>

<<<
 M( divides_2(x_1, x_2) ) =  	[[0], [0]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1 	+ 	[[0, 0], [0, 0]] 	* 	x_2
>>>

<<<
 M( if_3(x_1, ..., x_3) ) =  	[[0], [0]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1 	+ 	[[0, 0], [0, 0]] 	* 	x_2 	+ 	[[0, 0], [0, 0]] 	* 	x_3
>>>

<<<
 M( 0 ) =  	[[4], [0]]
>>>

<<<
 M( sieve_1(x_1) ) =  	[[0], [0]] 	+ 	[[0, 0], [0, 2]] 	* 	x_1
>>>

<<<
 M( cons_2(x_1, x_2) ) =  	[[0], [2]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1 	+ 	[[1, 3], [0, 1]] 	* 	x_2
>>>

<<<
 M( from_1(x_1) ) =  	[[0], [0]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1
>>>

Tuple symbols: 
<<<
 M( SIEVE_1(x_1) ) =  	[[0], [0]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1
>>>

<<<
 M( c1_1(x_1) ) =  	[[0], [0]] 	+ 	[[1, 0], [0, 0]] 	* 	x_1
>>>

<<<
 M( FILTER_2(x_1, x_2) ) =  	[[0], [2]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1 	+ 	[[1, 0], [0, 0]] 	* 	x_2
>>>

<<<
 M( FROM_1(x_1) ) =  	[[0], [0]] 	+ 	[[0, 0], [0, 0]] 	* 	x_1
>>>

<<<
 M( c8_2(x_1, x_2) ) =  	[[0], [0]] 	+ 	[[1, 0], [0, 0]] 	* 	x_1 	+ 	[[1, 0], [0, 0]] 	* 	x_2
>>>

<<<
 M( c8_1(x_1) ) =  	[[0], [0]] 	+ 	[[1, 0], [0, 0]] 	* 	x_1
>>>

<<<
 M( c6_1(x_1) ) =  	[[3], [0]] 	+ 	[[1, 0], [0, 0]] 	* 	x_1
>>>

<<<
 M( PRIMES ) =  	[[4], [4]]
>>>

<<<
 M( c2_1(x_1) ) =  	[[0], [0]] 	+ 	[[1, 0], [0, 0]] 	* 	x_1
>>>

<<<
 M( c7_2(x_1, x_2) ) =  	[[0], [0]] 	+ 	[[1, 0], [0, 0]] 	* 	x_1 	+ 	[[1, 0], [0, 0]] 	* 	x_2
>>>

<<<
 M( c7_1(x_1) ) =  	[[0], [2]] 	+ 	[[1, 0], [0, 0]] 	* 	x_1
>>>



Matrix type: 

We used a basic matrix type which is not further parametrizeable.





As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
----------------------------------------

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   sieve(cons(z0, z1)) -> cons(z0, filter(z0, sieve(z1)))
   filter(s(s(z0)), cons(z1, z2)) -> if(divides(s(s(z0)), z1), filter(s(s(z0)), z2), cons(z1, filter(z0, sieve(z1))))
   from(z0) -> cons(z0, from(s(z0)))
Tuples:
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(z2)), if(divides(s(s(z2)), z3), filter(s(s(z2)), filter(z3, sieve(z4))), cons(z3, filter(z2, sieve(z3)))))))), SIEVE(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, cons(z4, filter(z4, sieve(z5)))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
S tuples:
   FROM(s(s(x0))) -> c1(FROM(s(s(s(x0)))))
   SIEVE(cons(s(s(y0)), cons(z1, z2))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, z2), z3)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, sieve(z2)))), SIEVE(cons(z1, z2)))
   FILTER(s(s(x0)), cons(cons(s(s(x1)), cons(x2, x3)), x4)) -> c7(SIEVE(cons(s(s(x1)), cons(x2, x3))))
   SIEVE(cons(s(s(s(s(y0)))), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(s(s(y0)), cons(z1, cons(z2, z3)))) -> c8(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, sieve(z3)))))), SIEVE(cons(z1, cons(z2, z3))))
   SIEVE(cons(z0, cons(s(s(z1)), cons(z2, z3)))) -> c8(SIEVE(cons(s(s(z1)), cons(z2, z3))))
   SIEVE(cons(z0, cons(z1, cons(z2, cons(z3, z4))))) -> c8(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(y0)), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(y0)), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4))), z5)) -> c7(SIEVE(cons(s(s(s(s(y0)))), cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(y1)), cons(z3, z4))), z5)) -> c7(SIEVE(cons(z1, cons(s(s(y1)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(y3, y4)))), z5)) -> c7(SIEVE(cons(z1, cons(z2, cons(z3, cons(y3, y4))))))
   FILTER(s(s(s(s(s(s(y0)))))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(s(s(y0)))), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(s(s(y0)))), cons(cons(z1, cons(z2, cons(z3, z4))), z5)) -> c7(FILTER(s(s(y0)), cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, sieve(z4)))))))), SIEVE(cons(z1, cons(z2, cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(s(s(z2)), cons(z3, z4))), z5)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(s(s(z2)), if(divides(s(s(z2)), z3), filter(s(s(z2)), filter(z3, sieve(z4))), cons(z3, filter(z2, sieve(z3)))))))), SIEVE(cons(z1, cons(s(s(z2)), cons(z3, z4)))))
   FILTER(s(s(z0)), cons(cons(z1, cons(z2, cons(z3, cons(z4, z5)))), z6)) -> c7(FILTER(z0, cons(z1, filter(z1, cons(z2, filter(z2, cons(z3, filter(z3, cons(z4, filter(z4, sieve(z5)))))))))), SIEVE(cons(z1, cons(z2, cons(z3, cons(z4, z5))))))
K tuples:
   PRIMES -> c2(SIEVE(from(s(s(0)))))
   PRIMES -> c2(SIEVE(cons(s(s(0)), cons(s(s(s(0))), cons(s(s(s(s(0)))), cons(s(s(s(s(s(0))))), from(s(s(s(s(s(s(0)))))))))))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(y2, y3)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(y2, y3))))
   FILTER(s(s(z0)), cons(z1, cons(z2, cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(z2, cons(cons(y2, y3), y4))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(y1, y2), z3))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(y1, y2), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(s(s(y1)), cons(y2, y3)), z3))) -> c6(FILTER(s(s(z0)), cons(cons(s(s(y1)), cons(y2, y3)), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(y1, cons(y2, cons(y3, y4))), z3))) -> c6(FILTER(s(s(z0)), cons(cons(y1, cons(y2, cons(y3, y4))), z3)))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(y3, y4))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(y3, y4)))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5))))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(y2, cons(cons(y3, y4), y5)))))
   FILTER(s(s(s(s(y0)))), cons(z1, cons(cons(z2, z3), cons(cons(y2, y3), y4)))) -> c6(FILTER(s(s(s(s(y0)))), cons(cons(z2, z3), cons(cons(y2, y3), y4))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(s(s(y2)), cons(y3, y4)), y5))))
   FILTER(s(s(z0)), cons(z1, cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6)))) -> c6(FILTER(s(s(z0)), cons(cons(z2, z3), cons(cons(y2, cons(y3, cons(y4, y5))), y6))))
Defined Rule Symbols:   sieve_1, filter_2, from_1

Defined Pair Symbols:   PRIMES, FROM_1, SIEVE_1, FILTER_2

Compound Symbols:   c2_1, c1_1, c8_2, c7_2, c7_1, c6_1, c8_1


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

(115) RelTrsToWeightedTrsProof (UPPER BOUND(ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(116)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   primes -> sieve(from(s(s(0)))) [1]
   from(X) -> cons(X, from(s(X))) [1]
   head(cons(X, Y)) -> X [1]
   tail(cons(X, Y)) -> Y [1]
   if(true, X, Y) -> X [1]
   if(false, X, Y) -> Y [1]
   filter(s(s(X)), cons(Y, Z)) -> if(divides(s(s(X)), Y), filter(s(s(X)), Z), cons(Y, filter(X, sieve(Y)))) [1]
   sieve(cons(X, Y)) -> cons(X, filter(X, sieve(Y))) [1]

Rewrite Strategy: INNERMOST
----------------------------------------

(117) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(118)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   primes -> sieve(from(s(s(0)))) [1]
   from(X) -> cons(X, from(s(X))) [1]
   head(cons(X, Y)) -> X [1]
   tail(cons(X, Y)) -> Y [1]
   if(true, X, Y) -> X [1]
   if(false, X, Y) -> Y [1]
   filter(s(s(X)), cons(Y, Z)) -> if(divides(s(s(X)), Y), filter(s(s(X)), Z), cons(Y, filter(X, sieve(Y)))) [1]
   sieve(cons(X, Y)) -> cons(X, filter(X, sieve(Y))) [1]

The TRS has the following type information:
primes :: 0:s:cons
sieve :: 0:s:cons -> 0:s:cons
from :: 0:s:cons -> 0:s:cons
s :: 0:s:cons -> 0:s:cons
0 :: 0:s:cons
cons :: 0:s:cons -> 0:s:cons -> 0:s:cons
head :: 0:s:cons -> 0:s:cons
tail :: 0:s:cons -> 0:s:cons
if :: true:false:divides -> 0:s:cons -> 0:s:cons -> 0:s:cons
true :: true:false:divides
false :: true:false:divides
filter :: 0:s:cons -> 0:s:cons -> 0:s:cons
divides :: 0:s:cons -> 0:s:cons -> true:false:divides

Rewrite Strategy: INNERMOST
----------------------------------------

(119) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:

   head(v0) -> null_head [0]
   tail(v0) -> null_tail [0]
   if(v0, v1, v2) -> null_if [0]
   filter(v0, v1) -> null_filter [0]
   sieve(v0) -> null_sieve [0]

And the following fresh constants:    null_head, null_tail, null_if, null_filter, null_sieve

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

(120)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   primes -> sieve(from(s(s(0)))) [1]
   from(X) -> cons(X, from(s(X))) [1]
   head(cons(X, Y)) -> X [1]
   tail(cons(X, Y)) -> Y [1]
   if(true, X, Y) -> X [1]
   if(false, X, Y) -> Y [1]
   filter(s(s(X)), cons(Y, Z)) -> if(divides(s(s(X)), Y), filter(s(s(X)), Z), cons(Y, filter(X, sieve(Y)))) [1]
   sieve(cons(X, Y)) -> cons(X, filter(X, sieve(Y))) [1]
   head(v0) -> null_head [0]
   tail(v0) -> null_tail [0]
   if(v0, v1, v2) -> null_if [0]
   filter(v0, v1) -> null_filter [0]
   sieve(v0) -> null_sieve [0]

The TRS has the following type information:
primes :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
sieve :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
from :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
s :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
0 :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
cons :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
head :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
tail :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
if :: true:false:divides -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
true :: true:false:divides
false :: true:false:divides
filter :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
divides :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve -> true:false:divides
null_head :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
null_tail :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
null_if :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
null_filter :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve
null_sieve :: 0:s:cons:null_head:null_tail:null_if:null_filter:null_sieve

Rewrite Strategy: INNERMOST
----------------------------------------

(121) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   true => 1
   false => 0
   null_head => 0
   null_tail => 0
   null_if => 0
   null_filter => 0
   null_sieve => 0

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

(122)
Obligation:
Complexity RNTS consisting of the following rules:

   filter(z, z') -{ 1 }-> if(1 + (1 + (1 + X)) + Y, filter(1 + (1 + X), Z), 1 + Y + filter(X, sieve(Y))) :|: Z >= 0, z = 1 + (1 + X), Y >= 0, X >= 0, z' = 1 + Y + Z
   filter(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   from(z) -{ 1 }-> 1 + X + from(1 + X) :|: X >= 0, z = X
   head(z) -{ 1 }-> X :|: Y >= 0, z = 1 + X + Y, X >= 0
   head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   if(z, z', z'') -{ 1 }-> X :|: z' = X, Y >= 0, z = 1, z'' = Y, X >= 0
   if(z, z', z'') -{ 1 }-> Y :|: z' = X, Y >= 0, z'' = Y, X >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   primes -{ 1 }-> sieve(from(1 + (1 + 0))) :|: 
   sieve(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   sieve(z) -{ 1 }-> 1 + X + filter(X, sieve(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   tail(z) -{ 1 }-> Y :|: Y >= 0, z = 1 + X + Y, X >= 0
   tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0

Only complete derivations are relevant for the runtime complexity.

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

(123) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   primes
   head_1
   tail_1

(c) The following functions are completely defined:

   filter_2
   sieve_1
   from_1
   if_3

Due to the following rules being added:

   filter(v0, v1) -> 0 [0]
   sieve(v0) -> 0 [0]
   if(v0, v1, v2) -> 0 [0]

And the following fresh constants: none

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

(124)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   primes -> sieve(from(s(s(0)))) [1]
   from(X) -> cons(X, from(s(X))) [1]
   head(cons(X, Y)) -> X [1]
   tail(cons(X, Y)) -> Y [1]
   if(true, X, Y) -> X [1]
   if(false, X, Y) -> Y [1]
   filter(s(s(X)), cons(Y, Z)) -> if(divides(s(s(X)), Y), filter(s(s(X)), Z), cons(Y, filter(X, sieve(Y)))) [1]
   sieve(cons(X, Y)) -> cons(X, filter(X, sieve(Y))) [1]
   filter(v0, v1) -> 0 [0]
   sieve(v0) -> 0 [0]
   if(v0, v1, v2) -> 0 [0]

The TRS has the following type information:
primes :: 0:s:cons
sieve :: 0:s:cons -> 0:s:cons
from :: 0:s:cons -> 0:s:cons
s :: 0:s:cons -> 0:s:cons
0 :: 0:s:cons
cons :: 0:s:cons -> 0:s:cons -> 0:s:cons
head :: 0:s:cons -> 0:s:cons
tail :: 0:s:cons -> 0:s:cons
if :: true:false:divides -> 0:s:cons -> 0:s:cons -> 0:s:cons
true :: true:false:divides
false :: true:false:divides
filter :: 0:s:cons -> 0:s:cons -> 0:s:cons
divides :: 0:s:cons -> 0:s:cons -> true:false:divides

Rewrite Strategy: INNERMOST
----------------------------------------

(125) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(126)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   primes -> sieve(cons(s(s(0)), from(s(s(s(0)))))) [2]
   from(X) -> cons(X, from(s(X))) [1]
   head(cons(X, Y)) -> X [1]
   tail(cons(X, Y)) -> Y [1]
   if(true, X, Y) -> X [1]
   if(false, X, Y) -> Y [1]
   filter(s(s(X)), cons(cons(X', Y''), cons(Y', Z'))) -> if(divides(s(s(X)), cons(X', Y'')), if(divides(s(s(X)), Y'), filter(s(s(X)), Z'), cons(Y', filter(X, sieve(Y')))), cons(cons(X', Y''), filter(X, cons(X', filter(X', sieve(Y'')))))) [3]
   filter(s(s(X)), cons(Y, cons(Y', Z'))) -> if(divides(s(s(X)), Y), if(divides(s(s(X)), Y'), filter(s(s(X)), Z'), cons(Y', filter(X, sieve(Y')))), cons(Y, filter(X, 0))) [2]
   filter(s(s(X)), cons(cons(X'', Y1), Z)) -> if(divides(s(s(X)), cons(X'', Y1)), 0, cons(cons(X'', Y1), filter(X, cons(X'', filter(X'', sieve(Y1)))))) [2]
   filter(s(s(X)), cons(Y, Z)) -> if(divides(s(s(X)), Y), 0, cons(Y, filter(X, 0))) [1]
   sieve(cons(X, cons(X1, Y2))) -> cons(X, filter(X, cons(X1, filter(X1, sieve(Y2))))) [2]
   sieve(cons(X, Y)) -> cons(X, filter(X, 0)) [1]
   filter(v0, v1) -> 0 [0]
   sieve(v0) -> 0 [0]
   if(v0, v1, v2) -> 0 [0]

The TRS has the following type information:
primes :: 0:s:cons
sieve :: 0:s:cons -> 0:s:cons
from :: 0:s:cons -> 0:s:cons
s :: 0:s:cons -> 0:s:cons
0 :: 0:s:cons
cons :: 0:s:cons -> 0:s:cons -> 0:s:cons
head :: 0:s:cons -> 0:s:cons
tail :: 0:s:cons -> 0:s:cons
if :: true:false:divides -> 0:s:cons -> 0:s:cons -> 0:s:cons
true :: true:false:divides
false :: true:false:divides
filter :: 0:s:cons -> 0:s:cons -> 0:s:cons
divides :: 0:s:cons -> 0:s:cons -> true:false:divides

Rewrite Strategy: INNERMOST
----------------------------------------

(127) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   true => 1
   false => 0

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

(128)
Obligation:
Complexity RNTS consisting of the following rules:

   filter(z, z') -{ 2 }-> if(1 + (1 + (1 + X)) + Y, if(1 + (1 + (1 + X)) + Y', filter(1 + (1 + X), Z'), 1 + Y' + filter(X, sieve(Y'))), 1 + Y + filter(X, 0)) :|: z = 1 + (1 + X), Y >= 0, Y' >= 0, Z' >= 0, X >= 0, z' = 1 + Y + (1 + Y' + Z')
   filter(z, z') -{ 1 }-> if(1 + (1 + (1 + X)) + Y, 0, 1 + Y + filter(X, 0)) :|: Z >= 0, z = 1 + (1 + X), Y >= 0, X >= 0, z' = 1 + Y + Z
   filter(z, z') -{ 3 }-> if(1 + (1 + (1 + X)) + (1 + X' + Y''), if(1 + (1 + (1 + X)) + Y', filter(1 + (1 + X), Z'), 1 + Y' + filter(X, sieve(Y'))), 1 + (1 + X' + Y'') + filter(X, 1 + X' + filter(X', sieve(Y'')))) :|: z' = 1 + (1 + X' + Y'') + (1 + Y' + Z'), z = 1 + (1 + X), Y'' >= 0, Y' >= 0, Z' >= 0, X >= 0, X' >= 0
   filter(z, z') -{ 2 }-> if(1 + (1 + (1 + X)) + (1 + X'' + Y1), 0, 1 + (1 + X'' + Y1) + filter(X, 1 + X'' + filter(X'', sieve(Y1)))) :|: Z >= 0, z = 1 + (1 + X), Y1 >= 0, z' = 1 + (1 + X'' + Y1) + Z, X >= 0, X'' >= 0
   filter(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   from(z) -{ 1 }-> 1 + X + from(1 + X) :|: X >= 0, z = X
   head(z) -{ 1 }-> X :|: Y >= 0, z = 1 + X + Y, X >= 0
   if(z, z', z'') -{ 1 }-> X :|: z' = X, Y >= 0, z = 1, z'' = Y, X >= 0
   if(z, z', z'') -{ 1 }-> Y :|: z' = X, Y >= 0, z'' = Y, X >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   primes -{ 2 }-> sieve(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) :|: 
   sieve(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   sieve(z) -{ 1 }-> 1 + X + filter(X, 0) :|: Y >= 0, z = 1 + X + Y, X >= 0
   sieve(z) -{ 2 }-> 1 + X + filter(X, 1 + X1 + filter(X1, sieve(Y2))) :|: X1 >= 0, z = 1 + X + (1 + X1 + Y2), Y2 >= 0, X >= 0
   tail(z) -{ 1 }-> Y :|: Y >= 0, z = 1 + X + Y, X >= 0


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

(129) InliningProof (UPPER BOUND(ID))
Inlined the following terminating rules on right-hand sides where appropriate:

   if(z, z', z'') -{ 1 }-> X :|: z' = X, Y >= 0, z = 1, z'' = Y, X >= 0
   if(z, z', z'') -{ 1 }-> Y :|: z' = X, Y >= 0, z'' = Y, X >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0

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

(130)
Obligation:
Complexity RNTS consisting of the following rules:

   filter(z, z') -{ 2 }-> if(1 + (1 + (1 + X)) + Y, if(1 + (1 + (1 + X)) + Y', filter(1 + (1 + X), Z'), 1 + Y' + filter(X, sieve(Y'))), 1 + Y + filter(X, 0)) :|: z = 1 + (1 + X), Y >= 0, Y' >= 0, Z' >= 0, X >= 0, z' = 1 + Y + (1 + Y' + Z')
   filter(z, z') -{ 1 }-> if(1 + (1 + (1 + X)) + Y, 0, 1 + Y + filter(X, 0)) :|: Z >= 0, z = 1 + (1 + X), Y >= 0, X >= 0, z' = 1 + Y + Z
   filter(z, z') -{ 3 }-> if(1 + (1 + (1 + X)) + (1 + X' + Y''), if(1 + (1 + (1 + X)) + Y', filter(1 + (1 + X), Z'), 1 + Y' + filter(X, sieve(Y'))), 1 + (1 + X' + Y'') + filter(X, 1 + X' + filter(X', sieve(Y'')))) :|: z' = 1 + (1 + X' + Y'') + (1 + Y' + Z'), z = 1 + (1 + X), Y'' >= 0, Y' >= 0, Z' >= 0, X >= 0, X' >= 0
   filter(z, z') -{ 2 }-> if(1 + (1 + (1 + X)) + (1 + X'' + Y1), 0, 1 + (1 + X'' + Y1) + filter(X, 1 + X'' + filter(X'', sieve(Y1)))) :|: Z >= 0, z = 1 + (1 + X), Y1 >= 0, z' = 1 + (1 + X'' + Y1) + Z, X >= 0, X'' >= 0
   filter(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   from(z) -{ 1 }-> 1 + X + from(1 + X) :|: X >= 0, z = X
   head(z) -{ 1 }-> X :|: Y >= 0, z = 1 + X + Y, X >= 0
   if(z, z', z'') -{ 1 }-> X :|: z' = X, Y >= 0, z = 1, z'' = Y, X >= 0
   if(z, z', z'') -{ 1 }-> Y :|: z' = X, Y >= 0, z'' = Y, X >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   primes -{ 2 }-> sieve(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) :|: 
   sieve(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   sieve(z) -{ 1 }-> 1 + X + filter(X, 0) :|: Y >= 0, z = 1 + X + Y, X >= 0
   sieve(z) -{ 2 }-> 1 + X + filter(X, 1 + X1 + filter(X1, sieve(Y2))) :|: X1 >= 0, z = 1 + X + (1 + X1 + Y2), Y2 >= 0, X >= 0
   tail(z) -{ 1 }-> Y :|: Y >= 0, z = 1 + X + Y, X >= 0


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

(131) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(132)
Obligation:
Complexity RNTS consisting of the following rules:

   filter(z, z') -{ 2 }-> if(1 + (1 + (1 + (z - 2))) + Y, if(1 + (1 + (1 + (z - 2))) + Y', filter(1 + (1 + (z - 2)), Z'), 1 + Y' + filter(z - 2, sieve(Y'))), 1 + Y + filter(z - 2, 0)) :|: Y >= 0, Y' >= 0, Z' >= 0, z - 2 >= 0, z' = 1 + Y + (1 + Y' + Z')
   filter(z, z') -{ 1 }-> if(1 + (1 + (1 + (z - 2))) + Y, 0, 1 + Y + filter(z - 2, 0)) :|: Z >= 0, Y >= 0, z - 2 >= 0, z' = 1 + Y + Z
   filter(z, z') -{ 3 }-> if(1 + (1 + (1 + (z - 2))) + (1 + X' + Y''), if(1 + (1 + (1 + (z - 2))) + Y', filter(1 + (1 + (z - 2)), Z'), 1 + Y' + filter(z - 2, sieve(Y'))), 1 + (1 + X' + Y'') + filter(z - 2, 1 + X' + filter(X', sieve(Y'')))) :|: z' = 1 + (1 + X' + Y'') + (1 + Y' + Z'), Y'' >= 0, Y' >= 0, Z' >= 0, z - 2 >= 0, X' >= 0
   filter(z, z') -{ 2 }-> if(1 + (1 + (1 + (z - 2))) + (1 + X'' + Y1), 0, 1 + (1 + X'' + Y1) + filter(z - 2, 1 + X'' + filter(X'', sieve(Y1)))) :|: Z >= 0, Y1 >= 0, z' = 1 + (1 + X'' + Y1) + Z, z - 2 >= 0, X'' >= 0
   filter(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z + from(1 + z) :|: z >= 0
   head(z) -{ 1 }-> X :|: Y >= 0, z = 1 + X + Y, X >= 0
   if(z, z', z'') -{ 1 }-> z' :|: z'' >= 0, z = 1, z' >= 0
   if(z, z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' >= 0, z = 0
   if(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   primes -{ 2 }-> sieve(1 + (1 + (1 + 0)) + from(1 + (1 + (1 + 0)))) :|: 
   sieve(z) -{ 0 }-> 0 :|: z >= 0
   sieve(z) -{ 1 }-> 1 + X + filter(X, 0) :|: Y >= 0, z = 1 + X + Y, X >= 0
   sieve(z) -{ 2 }-> 1 + X + filter(X, 1 + X1 + filter(X1, sieve(Y2))) :|: X1 >= 0, z = 1 + X + (1 + X1 + Y2), Y2 >= 0, X >= 0
   tail(z) -{ 1 }-> Y :|: Y >= 0, z = 1 + X + Y, X >= 0