KILLED proof of input_RgxshPNfHb.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) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (4) CpxTRS (5) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms] (6) CpxWeightedTrs (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (8) CpxTypedWeightedTrs (9) CompletionProof [UPPER BOUND(ID), 0 ms] (10) CpxTypedWeightedCompleteTrs (11) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (12) CpxTypedWeightedCompleteTrs (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (14) CpxRNTS (15) InliningProof [UPPER BOUND(ID), 0 ms] (16) CpxRNTS (17) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms] (18) CpxRNTS (19) CompletionProof [UPPER BOUND(ID), 0 ms] (20) CpxTypedWeightedCompleteTrs (21) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (22) CpxRNTS (23) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (24) CdtProblem (25) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (26) CdtProblem (27) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (28) CdtProblem (29) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (30) CdtProblem (31) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (32) CdtProblem (33) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (34) CdtProblem (35) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (36) CdtProblem (37) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (38) CdtProblem (39) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (40) CdtProblem (41) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (42) CdtProblem (43) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (44) CdtProblem (45) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (46) CdtProblem (47) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (48) CdtProblem (49) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (50) CdtProblem (51) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (52) CdtProblem (53) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (54) CdtProblem (55) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (56) CdtProblem (57) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (58) CdtProblem (59) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (60) CdtProblem (61) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (62) CdtProblem (63) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (64) CdtProblem (65) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (66) CdtProblem (67) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (68) CdtProblem (69) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (70) CdtProblem (71) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (74) CdtProblem (75) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (76) CdtProblem (77) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (78) CdtProblem (79) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (80) CdtProblem (81) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtRhsSimplificationProcessorProof [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) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (98) CdtProblem (99) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 14.2 s] (100) CdtProblem ---------------------------------------- (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) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (4) 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 ---------------------------------------- (5) RelTrsToWeightedTrsProof (UPPER BOUND(ID)) Transformed relative TRS to weighted TRS ---------------------------------------- (6) 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 ---------------------------------------- (7) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (8) 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 ---------------------------------------- (9) 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 ---------------------------------------- (10) 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 ---------------------------------------- (11) NarrowingProof (BOTH BOUNDS(ID, ID)) Narrowed the inner basic terms of all right-hand sides by a single narrowing step. ---------------------------------------- (12) 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 ---------------------------------------- (13) 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 ---------------------------------------- (14) 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 ---------------------------------------- (15) 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 ---------------------------------------- (16) 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 ---------------------------------------- (17) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (18) 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 ---------------------------------------- (19) 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 ---------------------------------------- (20) 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 ---------------------------------------- (21) 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 ---------------------------------------- (22) 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. ---------------------------------------- (23) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (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: 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 ---------------------------------------- (25) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 4 trailing nodes: TAIL(cons(z0, z1)) -> c3 IF(false, z0, z1) -> c5 IF(true, z0, z1) -> c4 HEAD(cons(z0, z1)) -> c2 ---------------------------------------- (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: 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 ---------------------------------------- (27) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (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: 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 ---------------------------------------- (29) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (30) 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 ---------------------------------------- (31) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: PRIMES -> c2(FROM(s(s(0)))) ---------------------------------------- (32) 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 ---------------------------------------- (33) 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))))) ---------------------------------------- (34) 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 ---------------------------------------- (35) 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 ---------------------------------------- (36) 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 ---------------------------------------- (37) 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))) ---------------------------------------- (38) 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 ---------------------------------------- (39) 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))) ---------------------------------------- (40) 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 ---------------------------------------- (41) 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))))))) ---------------------------------------- (42) 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 ---------------------------------------- (43) 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))))))))) ---------------------------------------- (44) 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 ---------------------------------------- (45) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace FROM(z0) -> c1(FROM(s(z0))) by FROM(s(x0)) -> c1(FROM(s(s(x0)))) ---------------------------------------- (46) 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))), from(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 ---------------------------------------- (47) 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))))))))))) ---------------------------------------- (48) 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))) FROM(s(x0)) -> c1(FROM(s(s(x0)))) 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: 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, FROM_1, PRIMES Compound Symbols: c6_1, c8_2, c7_2, c1_1, c2_1 ---------------------------------------- (49) 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))))))))))))) ---------------------------------------- (50) 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))) FROM(s(x0)) -> c1(FROM(s(s(x0)))) 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: 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, FROM_1, PRIMES Compound Symbols: c6_1, c8_2, c7_2, c1_1, c2_1 ---------------------------------------- (51) 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))))) ---------------------------------------- (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: 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 ---------------------------------------- (53) 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))) ---------------------------------------- (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: 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 ---------------------------------------- (55) 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))) ---------------------------------------- (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: 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 ---------------------------------------- (57) 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)))) ---------------------------------------- (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: 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 ---------------------------------------- (59) 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))))) ---------------------------------------- (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: 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 ---------------------------------------- (61) 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)))) ---------------------------------------- (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: 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 ---------------------------------------- (63) 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))))) ---------------------------------------- (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: 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 ---------------------------------------- (65) 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)))) ---------------------------------------- (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: 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 ---------------------------------------- (67) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (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: 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 ---------------------------------------- (69) 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))))) ---------------------------------------- (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: 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 ---------------------------------------- (71) 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))) ---------------------------------------- (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: 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 ---------------------------------------- (73) 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)))) ---------------------------------------- (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))))) 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 ---------------------------------------- (75) 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)))) ---------------------------------------- (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))))) 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 ---------------------------------------- (77) 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)))) ---------------------------------------- (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))))) 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 ---------------------------------------- (79) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (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))))) 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 ---------------------------------------- (81) 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))))) ---------------------------------------- (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))))) 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 ---------------------------------------- (83) 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)))))) ---------------------------------------- (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))))) 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 ---------------------------------------- (85) 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)))))) ---------------------------------------- (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))))) 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 ---------------------------------------- (87) 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))))) ---------------------------------------- (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))) 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 ---------------------------------------- (89) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (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(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 ---------------------------------------- (91) 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))))) ---------------------------------------- (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(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 ---------------------------------------- (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(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 ---------------------------------------- (95) 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))))) ---------------------------------------- (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(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 ---------------------------------------- (97) 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)))))) ---------------------------------------- (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(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 ---------------------------------------- (99) 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. ---------------------------------------- (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(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