Term Rewriting System R:
[X, Y, M, N]
filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Innermost Termination of R to be shown.

`   R`
`     ↳Dependency Pair Analysis`

R contains the following Dependency Pairs:

FILTER(cons(X, Y), 0, M) -> FILTER(Y, M, M)
FILTER(cons(X, Y), s(N), M) -> FILTER(Y, N, M)
SIEVE(cons(0, Y)) -> SIEVE(Y)
SIEVE(cons(s(N), Y)) -> SIEVE(filter(Y, N, N))
SIEVE(cons(s(N), Y)) -> FILTER(Y, N, N)
NATS(N) -> NATS(s(N))
ZPRIMES -> SIEVE(nats(s(s(0))))
ZPRIMES -> NATS(s(s(0)))

Furthermore, R contains three SCCs.

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳Forward Instantiation Transformation`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pairs:

FILTER(cons(X, Y), s(N), M) -> FILTER(Y, N, M)
FILTER(cons(X, Y), 0, M) -> FILTER(Y, M, M)

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

FILTER(cons(X, Y), 0, M) -> FILTER(Y, M, M)
two new Dependency Pairs are created:

FILTER(cons(X, cons(X'', Y'')), 0, 0) -> FILTER(cons(X'', Y''), 0, 0)
FILTER(cons(X, cons(X'', Y'')), 0, s(N'')) -> FILTER(cons(X'', Y''), s(N''), s(N''))

The transformation is resulting in two new DP problems:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳Forward Instantiation Transformation`
`           →DP Problem 5`
`             ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pair:

FILTER(cons(X, cons(X'', Y'')), 0, 0) -> FILTER(cons(X'', Y''), 0, 0)

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

FILTER(cons(X, cons(X'', Y'')), 0, 0) -> FILTER(cons(X'', Y''), 0, 0)
one new Dependency Pair is created:

FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), 0, 0) -> FILTER(cons(X'''', cons(X''''', Y'''')), 0, 0)

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳FwdInst`
`             ...`
`               →DP Problem 6`
`                 ↳Polynomial Ordering`
`           →DP Problem 5`
`             ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pair:

FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), 0, 0) -> FILTER(cons(X'''', cons(X''''', Y'''')), 0, 0)

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

The following dependency pair can be strictly oriented:

FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), 0, 0) -> FILTER(cons(X'''', cons(X''''', Y'''')), 0, 0)

There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
 POL(FILTER(x1, x2, x3)) =  1 + x1 POL(0) =  0 POL(cons(x1, x2)) =  1 + x2

resulting in one new DP problem.

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳FwdInst`
`             ...`
`               →DP Problem 12`
`                 ↳Dependency Graph`
`           →DP Problem 5`
`             ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pair:

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳FwdInst`
`           →DP Problem 5`
`             ↳Forward Instantiation Transformation`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pairs:

FILTER(cons(X, cons(X'', Y'')), 0, s(N'')) -> FILTER(cons(X'', Y''), s(N''), s(N''))
FILTER(cons(X, Y), s(N), M) -> FILTER(Y, N, M)

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

FILTER(cons(X, Y), s(N), M) -> FILTER(Y, N, M)
two new Dependency Pairs are created:

FILTER(cons(X, cons(X'', Y'')), s(s(N'')), M'') -> FILTER(cons(X'', Y''), s(N''), M'')
FILTER(cons(X, cons(X'', cons(X'''', Y''''))), s(0), s(N'''')) -> FILTER(cons(X'', cons(X'''', Y'''')), 0, s(N''''))

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳FwdInst`
`           →DP Problem 5`
`             ↳FwdInst`
`             ...`
`               →DP Problem 7`
`                 ↳Forward Instantiation Transformation`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pairs:

FILTER(cons(X, cons(X'', cons(X'''', Y''''))), s(0), s(N'''')) -> FILTER(cons(X'', cons(X'''', Y'''')), 0, s(N''''))
FILTER(cons(X, cons(X'', Y'')), s(s(N'')), M'') -> FILTER(cons(X'', Y''), s(N''), M'')
FILTER(cons(X, cons(X'', Y'')), 0, s(N'')) -> FILTER(cons(X'', Y''), s(N''), s(N''))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

FILTER(cons(X, cons(X'', Y'')), 0, s(N'')) -> FILTER(cons(X'', Y''), s(N''), s(N''))
two new Dependency Pairs are created:

FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), 0, s(s(N''''))) -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), s(s(N'''')))
FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), 0, s(0)) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(0))

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳FwdInst`
`           →DP Problem 5`
`             ↳FwdInst`
`             ...`
`               →DP Problem 8`
`                 ↳Forward Instantiation Transformation`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pairs:

FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), 0, s(0)) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(0))
FILTER(cons(X, cons(X'', Y'')), s(s(N'')), M'') -> FILTER(cons(X'', Y''), s(N''), M'')
FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), 0, s(s(N''''))) -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), s(s(N'''')))
FILTER(cons(X, cons(X'', cons(X'''', Y''''))), s(0), s(N'''')) -> FILTER(cons(X'', cons(X'''', Y'''')), 0, s(N''''))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

FILTER(cons(X, cons(X'', Y'')), s(s(N'')), M'') -> FILTER(cons(X'', Y''), s(N''), M'')
two new Dependency Pairs are created:

FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), s(s(s(N''''))), M'''') -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), M'''')
FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), s(s(0)), s(N'''''')) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(N''''''))

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳FwdInst`
`           →DP Problem 5`
`             ↳FwdInst`
`             ...`
`               →DP Problem 9`
`                 ↳Forward Instantiation Transformation`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pairs:

FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), s(s(0)), s(N'''''')) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(N''''''))
FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), s(s(s(N''''))), M'''') -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), M'''')
FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), 0, s(s(N''''))) -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), s(s(N'''')))
FILTER(cons(X, cons(X'', cons(X'''', Y''''))), s(0), s(N'''')) -> FILTER(cons(X'', cons(X'''', Y'''')), 0, s(N''''))
FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), 0, s(0)) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(0))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

FILTER(cons(X, cons(X'', cons(X'''', Y''''))), s(0), s(N'''')) -> FILTER(cons(X'', cons(X'''', Y'''')), 0, s(N''''))
two new Dependency Pairs are created:

FILTER(cons(X, cons(X''', cons(X''''', cons(X'''''''', Y'''''')))), s(0), s(s(N''''''))) -> FILTER(cons(X''', cons(X''''', cons(X'''''''', Y''''''))), 0, s(s(N'''''')))
FILTER(cons(X, cons(X''', cons(X'''''', cons(X'''0'', cons(X'''''''', Y''''''''))))), s(0), s(0)) -> FILTER(cons(X''', cons(X'''''', cons(X'''0'', cons(X'''''''', Y'''''''')))), 0, s(0))

The transformation is resulting in two new DP problems:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳FwdInst`
`           →DP Problem 5`
`             ↳FwdInst`
`             ...`
`               →DP Problem 10`
`                 ↳Polynomial Ordering`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pairs:

FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), 0, s(0)) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(0))
FILTER(cons(X, cons(X''', cons(X'''''', cons(X'''0'', cons(X'''''''', Y''''''''))))), s(0), s(0)) -> FILTER(cons(X''', cons(X'''''', cons(X'''0'', cons(X'''''''', Y'''''''')))), 0, s(0))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), 0, s(0)) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(0))
FILTER(cons(X, cons(X''', cons(X'''''', cons(X'''0'', cons(X'''''''', Y''''''''))))), s(0), s(0)) -> FILTER(cons(X''', cons(X'''''', cons(X'''0'', cons(X'''''''', Y'''''''')))), 0, s(0))

There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
 POL(FILTER(x1, x2, x3)) =  1 + x1 + x3 POL(0) =  0 POL(cons(x1, x2)) =  1 + x2 POL(s(x1)) =  0

resulting in one new DP problem.

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`           →DP Problem 4`
`             ↳FwdInst`
`           →DP Problem 5`
`             ↳FwdInst`
`             ...`
`               →DP Problem 11`
`                 ↳Polynomial Ordering`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pairs:

FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), s(s(s(N''''))), M'''') -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), M'''')
FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), 0, s(s(N''''))) -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), s(s(N'''')))
FILTER(cons(X, cons(X''', cons(X''''', cons(X'''''''', Y'''''')))), s(0), s(s(N''''''))) -> FILTER(cons(X''', cons(X''''', cons(X'''''''', Y''''''))), 0, s(s(N'''''')))
FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), s(s(0)), s(N'''''')) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(N''''''))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), s(s(s(N''''))), M'''') -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), M'''')
FILTER(cons(X, cons(X'''', cons(X''''', Y''''))), 0, s(s(N''''))) -> FILTER(cons(X'''', cons(X''''', Y'''')), s(s(N'''')), s(s(N'''')))
FILTER(cons(X, cons(X''', cons(X''''', cons(X'''''''', Y'''''')))), s(0), s(s(N''''''))) -> FILTER(cons(X''', cons(X''''', cons(X'''''''', Y''''''))), 0, s(s(N'''''')))
FILTER(cons(X, cons(X'''', cons(X'''0, cons(X'''''', Y'''''')))), s(s(0)), s(N'''''')) -> FILTER(cons(X'''', cons(X'''0, cons(X'''''', Y''''''))), s(0), s(N''''''))

There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
 POL(FILTER(x1, x2, x3)) =  1 + x1 + x3 POL(0) =  0 POL(cons(x1, x2)) =  1 + x2 POL(s(x1)) =  0

resulting in one new DP problem.

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`       →DP Problem 2`
`         ↳Instantiation Transformation`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pair:

NATS(N) -> NATS(s(N))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

NATS(N) -> NATS(s(N))
one new Dependency Pair is created:

NATS(s(N'')) -> NATS(s(s(N'')))

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`           →DP Problem 15`
`             ↳Instantiation Transformation`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pair:

NATS(s(N'')) -> NATS(s(s(N'')))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

NATS(s(N'')) -> NATS(s(s(N'')))
one new Dependency Pair is created:

NATS(s(s(N''''))) -> NATS(s(s(s(N''''))))

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`           →DP Problem 15`
`             ↳Inst`
`             ...`
`               →DP Problem 16`
`                 ↳Instantiation Transformation`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pair:

NATS(s(s(N''''))) -> NATS(s(s(s(N''''))))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

NATS(s(s(N''''))) -> NATS(s(s(s(N''''))))
one new Dependency Pair is created:

NATS(s(s(s(N'''''')))) -> NATS(s(s(s(s(N'''''')))))

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`           →DP Problem 15`
`             ↳Inst`
`             ...`
`               →DP Problem 17`
`                 ↳Instantiation Transformation`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pair:

NATS(s(s(s(N'''''')))) -> NATS(s(s(s(s(N'''''')))))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

NATS(s(s(s(N'''''')))) -> NATS(s(s(s(s(N'''''')))))
one new Dependency Pair is created:

NATS(s(s(s(s(N''''''''))))) -> NATS(s(s(s(s(s(N''''''''))))))

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`           →DP Problem 15`
`             ↳Inst`
`             ...`
`               →DP Problem 18`
`                 ↳Instantiation Transformation`
`       →DP Problem 3`
`         ↳Remaining`

Dependency Pair:

NATS(s(s(s(s(N''''''''))))) -> NATS(s(s(s(s(s(N''''''''))))))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

NATS(s(s(s(s(N''''''''))))) -> NATS(s(s(s(s(s(N''''''''))))))
one new Dependency Pair is created:

NATS(s(s(s(s(s(N'''''''''')))))) -> NATS(s(s(s(s(s(s(N'''''''''')))))))

The transformation is resulting in one new DP problem:

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining Obligation(s)`

The following remains to be proven:
• Dependency Pair:

NATS(s(s(s(s(s(N'''''''''')))))) -> NATS(s(s(s(s(s(s(N'''''''''')))))))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

• Dependency Pairs:

SIEVE(cons(s(N), Y)) -> SIEVE(filter(Y, N, N))
SIEVE(cons(0, Y)) -> SIEVE(Y)

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

`   R`
`     ↳DPs`
`       →DP Problem 1`
`         ↳FwdInst`
`       →DP Problem 2`
`         ↳Inst`
`       →DP Problem 3`
`         ↳Remaining Obligation(s)`

The following remains to be proven:
• Dependency Pair:

NATS(s(s(s(s(s(N'''''''''')))))) -> NATS(s(s(s(s(s(s(N'''''''''')))))))

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

• Dependency Pairs:

SIEVE(cons(s(N), Y)) -> SIEVE(filter(Y, N, N))
SIEVE(cons(0, Y)) -> SIEVE(Y)

Rules:

filter(cons(X, Y), 0, M) -> cons(0, filter(Y, M, M))
filter(cons(X, Y), s(N), M) -> cons(X, filter(Y, N, M))
sieve(cons(0, Y)) -> cons(0, sieve(Y))
sieve(cons(s(N), Y)) -> cons(s(N), sieve(filter(Y, N, N)))
nats(N) -> cons(N, nats(s(N)))
zprimes -> sieve(nats(s(s(0))))

Strategy:

innermost

Innermost Termination of R could not be shown.
Duration:
0:00 minutes