Term Rewriting System R:
[X, Y, Z]
f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X

Innermost Termination of R to be shown.



   R
Dependency Pair Analysis



R contains the following Dependency Pairs:

G(s(X)) -> G(X)
SEL(s(X), cons(Y, Z)) -> SEL(X, activate(Z))
SEL(s(X), cons(Y, Z)) -> ACTIVATE(Z)
ACTIVATE(nf(X)) -> F(activate(X))
ACTIVATE(nf(X)) -> ACTIVATE(X)
ACTIVATE(ng(X)) -> G(activate(X))
ACTIVATE(ng(X)) -> ACTIVATE(X)

Furthermore, R contains three SCCs.


   R
DPs
       →DP Problem 1
Forward Instantiation Transformation
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar


Dependency Pair:

G(s(X)) -> G(X)


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

G(s(X)) -> G(X)
one new Dependency Pair is created:

G(s(s(X''))) -> G(s(X''))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
           →DP Problem 4
Forward Instantiation Transformation
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar


Dependency Pair:

G(s(s(X''))) -> G(s(X''))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

G(s(s(X''))) -> G(s(X''))
one new Dependency Pair is created:

G(s(s(s(X'''')))) -> G(s(s(X'''')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
           →DP Problem 4
FwdInst
             ...
               →DP Problem 5
Argument Filtering and Ordering
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar


Dependency Pair:

G(s(s(s(X'''')))) -> G(s(s(X'''')))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




The following dependency pair can be strictly oriented:

G(s(s(s(X'''')))) -> G(s(s(X'''')))


There are no usable rules for innermost w.r.t. to the AFS that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
G(x1) -> G(x1)
s(x1) -> s(x1)


   R
DPs
       →DP Problem 1
FwdInst
           →DP Problem 4
FwdInst
             ...
               →DP Problem 6
Dependency Graph
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar


Dependency Pair:


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

ACTIVATE(ng(X)) -> ACTIVATE(X)
ACTIVATE(nf(X)) -> ACTIVATE(X)


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

ACTIVATE(nf(X)) -> ACTIVATE(X)
two new Dependency Pairs are created:

ACTIVATE(nf(nf(X''))) -> ACTIVATE(nf(X''))
ACTIVATE(nf(ng(X''))) -> ACTIVATE(ng(X''))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 7
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

ACTIVATE(nf(ng(X''))) -> ACTIVATE(ng(X''))
ACTIVATE(nf(nf(X''))) -> ACTIVATE(nf(X''))
ACTIVATE(ng(X)) -> ACTIVATE(X)


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

ACTIVATE(ng(X)) -> ACTIVATE(X)
three new Dependency Pairs are created:

ACTIVATE(ng(ng(X''))) -> ACTIVATE(ng(X''))
ACTIVATE(ng(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 7
FwdInst
             ...
               →DP Problem 8
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

ACTIVATE(ng(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(nf(nf(X''))) -> ACTIVATE(nf(X''))
ACTIVATE(ng(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(ng(X''))) -> ACTIVATE(ng(X''))
ACTIVATE(nf(ng(X''))) -> ACTIVATE(ng(X''))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

ACTIVATE(nf(nf(X''))) -> ACTIVATE(nf(X''))
two new Dependency Pairs are created:

ACTIVATE(nf(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(nf(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 7
FwdInst
             ...
               →DP Problem 9
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

ACTIVATE(nf(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(nf(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(ng(X''))) -> ACTIVATE(ng(X''))
ACTIVATE(nf(ng(X''))) -> ACTIVATE(ng(X''))
ACTIVATE(ng(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

ACTIVATE(nf(ng(X''))) -> ACTIVATE(ng(X''))
three new Dependency Pairs are created:

ACTIVATE(nf(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(nf(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(nf(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 7
FwdInst
             ...
               →DP Problem 10
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

ACTIVATE(nf(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))
ACTIVATE(nf(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(ng(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(nf(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(ng(X''))) -> ACTIVATE(ng(X''))
ACTIVATE(nf(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(nf(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

ACTIVATE(ng(ng(X''))) -> ACTIVATE(ng(X''))
three new Dependency Pairs are created:

ACTIVATE(ng(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(ng(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(ng(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 7
FwdInst
             ...
               →DP Problem 11
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

ACTIVATE(ng(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))
ACTIVATE(nf(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(nf(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(nf(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(ng(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(nf(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(ng(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(nf(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

ACTIVATE(ng(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
two new Dependency Pairs are created:

ACTIVATE(ng(nf(nf(nf(X''''''))))) -> ACTIVATE(nf(nf(nf(X''''''))))
ACTIVATE(ng(nf(nf(ng(X''''''))))) -> ACTIVATE(nf(nf(ng(X''''''))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 7
FwdInst
             ...
               →DP Problem 12
Forward Instantiation Transformation
       →DP Problem 3
Nar


Dependency Pairs:

ACTIVATE(nf(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))
ACTIVATE(ng(nf(nf(ng(X''''''))))) -> ACTIVATE(nf(nf(ng(X''''''))))
ACTIVATE(nf(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(nf(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(nf(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(nf(nf(nf(X''''''))))) -> ACTIVATE(nf(nf(nf(X''''''))))
ACTIVATE(ng(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(ng(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(nf(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(ng(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(ng(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

ACTIVATE(ng(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
three new Dependency Pairs are created:

ACTIVATE(ng(nf(ng(ng(X''''''))))) -> ACTIVATE(nf(ng(ng(X''''''))))
ACTIVATE(ng(nf(ng(nf(nf(X'''''''')))))) -> ACTIVATE(nf(ng(nf(nf(X'''''''')))))
ACTIVATE(ng(nf(ng(nf(ng(X'''''''')))))) -> ACTIVATE(nf(ng(nf(ng(X'''''''')))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 7
FwdInst
             ...
               →DP Problem 13
Argument Filtering and Ordering
       →DP Problem 3
Nar


Dependency Pairs:

ACTIVATE(ng(nf(ng(nf(ng(X'''''''')))))) -> ACTIVATE(nf(ng(nf(ng(X'''''''')))))
ACTIVATE(ng(nf(ng(nf(nf(X'''''''')))))) -> ACTIVATE(nf(ng(nf(nf(X'''''''')))))
ACTIVATE(ng(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))
ACTIVATE(ng(nf(nf(ng(X''''''))))) -> ACTIVATE(nf(nf(ng(X''''''))))
ACTIVATE(nf(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(nf(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(nf(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(nf(nf(nf(X''''''))))) -> ACTIVATE(nf(nf(nf(X''''''))))
ACTIVATE(ng(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(ng(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(nf(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(ng(nf(ng(ng(X''''''))))) -> ACTIVATE(nf(ng(ng(X''''''))))
ACTIVATE(nf(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




The following dependency pairs can be strictly oriented:

ACTIVATE(ng(nf(ng(nf(ng(X'''''''')))))) -> ACTIVATE(nf(ng(nf(ng(X'''''''')))))
ACTIVATE(ng(nf(ng(nf(nf(X'''''''')))))) -> ACTIVATE(nf(ng(nf(nf(X'''''''')))))
ACTIVATE(ng(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))
ACTIVATE(ng(nf(nf(ng(X''''''))))) -> ACTIVATE(nf(nf(ng(X''''''))))
ACTIVATE(nf(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(nf(nf(ng(X'''')))) -> ACTIVATE(nf(ng(X'''')))
ACTIVATE(nf(nf(nf(X'''')))) -> ACTIVATE(nf(nf(X'''')))
ACTIVATE(ng(nf(nf(nf(X''''''))))) -> ACTIVATE(nf(nf(nf(X''''''))))
ACTIVATE(ng(ng(nf(nf(X''''''))))) -> ACTIVATE(ng(nf(nf(X''''''))))
ACTIVATE(ng(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(nf(ng(ng(X'''')))) -> ACTIVATE(ng(ng(X'''')))
ACTIVATE(ng(nf(ng(ng(X''''''))))) -> ACTIVATE(nf(ng(ng(X''''''))))
ACTIVATE(nf(ng(nf(ng(X''''''))))) -> ACTIVATE(ng(nf(ng(X''''''))))


There are no usable rules for innermost w.r.t. to the AFS that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
ACTIVATE(x1) -> ACTIVATE(x1)
nf(x1) -> nf(x1)
ng(x1) -> ng(x1)


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 7
FwdInst
             ...
               →DP Problem 14
Dependency Graph
       →DP Problem 3
Nar


Dependency Pair:


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
Narrowing Transformation


Dependency Pair:

SEL(s(X), cons(Y, Z)) -> SEL(X, activate(Z))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

SEL(s(X), cons(Y, Z)) -> SEL(X, activate(Z))
three new Dependency Pairs are created:

SEL(s(X), cons(Y, nf(X''))) -> SEL(X, f(activate(X'')))
SEL(s(X), cons(Y, ng(X''))) -> SEL(X, g(activate(X'')))
SEL(s(X), cons(Y, Z')) -> SEL(X, Z')

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar
           →DP Problem 15
Narrowing Transformation


Dependency Pairs:

SEL(s(X), cons(Y, Z')) -> SEL(X, Z')
SEL(s(X), cons(Y, ng(X''))) -> SEL(X, g(activate(X'')))
SEL(s(X), cons(Y, nf(X''))) -> SEL(X, f(activate(X'')))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

SEL(s(X), cons(Y, nf(X''))) -> SEL(X, f(activate(X'')))
five new Dependency Pairs are created:

SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, cons(activate(X'''), nf(ng(activate(X''')))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, nf(activate(X''')))
SEL(s(X), cons(Y, nf(nf(X''')))) -> SEL(X, f(f(activate(X'''))))
SEL(s(X), cons(Y, nf(ng(X''')))) -> SEL(X, f(g(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, f(X'''))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar
           →DP Problem 15
Nar
             ...
               →DP Problem 16
Narrowing Transformation


Dependency Pairs:

SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, f(X'''))
SEL(s(X), cons(Y, nf(nf(X''')))) -> SEL(X, f(f(activate(X'''))))
SEL(s(X), cons(Y, nf(ng(X''')))) -> SEL(X, f(g(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, cons(activate(X'''), nf(ng(activate(X''')))))
SEL(s(X), cons(Y, ng(X''))) -> SEL(X, g(activate(X'')))
SEL(s(X), cons(Y, Z')) -> SEL(X, Z')


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

SEL(s(X), cons(Y, ng(X''))) -> SEL(X, g(activate(X'')))
four new Dependency Pairs are created:

SEL(s(X), cons(Y, ng(X'''))) -> SEL(X, ng(activate(X''')))
SEL(s(X), cons(Y, ng(nf(X''')))) -> SEL(X, g(f(activate(X'''))))
SEL(s(X), cons(Y, ng(ng(X''')))) -> SEL(X, g(g(activate(X'''))))
SEL(s(X), cons(Y, ng(X'''))) -> SEL(X, g(X'''))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar
           →DP Problem 15
Nar
             ...
               →DP Problem 17
Forward Instantiation Transformation


Dependency Pairs:

SEL(s(X), cons(Y, ng(X'''))) -> SEL(X, g(X'''))
SEL(s(X), cons(Y, ng(ng(X''')))) -> SEL(X, g(g(activate(X'''))))
SEL(s(X), cons(Y, ng(nf(X''')))) -> SEL(X, g(f(activate(X'''))))
SEL(s(X), cons(Y, nf(nf(X''')))) -> SEL(X, f(f(activate(X'''))))
SEL(s(X), cons(Y, nf(ng(X''')))) -> SEL(X, f(g(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, cons(activate(X'''), nf(ng(activate(X''')))))
SEL(s(X), cons(Y, Z')) -> SEL(X, Z')
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, f(X'''))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

SEL(s(X), cons(Y, Z')) -> SEL(X, Z')
seven new Dependency Pairs are created:

SEL(s(s(X'')), cons(Y, cons(Y'', Z'''))) -> SEL(s(X''), cons(Y'', Z'''))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(X''''')))) -> SEL(s(X''), cons(Y'', nf(X''''')))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(nf(X'''''))))) -> SEL(s(X''), cons(Y'', nf(nf(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(ng(X'''''))))) -> SEL(s(X''), cons(Y'', nf(ng(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(nf(X'''''))))) -> SEL(s(X''), cons(Y'', ng(nf(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(ng(X'''''))))) -> SEL(s(X''), cons(Y'', ng(ng(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(X''''')))) -> SEL(s(X''), cons(Y'', ng(X''''')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar
           →DP Problem 15
Nar
             ...
               →DP Problem 18
Forward Instantiation Transformation


Dependency Pairs:

SEL(s(s(X'')), cons(Y, cons(Y'', ng(X''''')))) -> SEL(s(X''), cons(Y'', ng(X''''')))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(ng(X'''''))))) -> SEL(s(X''), cons(Y'', ng(ng(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(nf(X'''''))))) -> SEL(s(X''), cons(Y'', ng(nf(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(ng(X'''''))))) -> SEL(s(X''), cons(Y'', nf(ng(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(nf(X'''''))))) -> SEL(s(X''), cons(Y'', nf(nf(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(X''''')))) -> SEL(s(X''), cons(Y'', nf(X''''')))
SEL(s(s(X'')), cons(Y, cons(Y'', Z'''))) -> SEL(s(X''), cons(Y'', Z'''))
SEL(s(X), cons(Y, ng(ng(X''')))) -> SEL(X, g(g(activate(X'''))))
SEL(s(X), cons(Y, ng(nf(X''')))) -> SEL(X, g(f(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, f(X'''))
SEL(s(X), cons(Y, nf(nf(X''')))) -> SEL(X, f(f(activate(X'''))))
SEL(s(X), cons(Y, nf(ng(X''')))) -> SEL(X, f(g(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, cons(activate(X'''), nf(ng(activate(X''')))))
SEL(s(X), cons(Y, ng(X'''))) -> SEL(X, g(X'''))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




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

SEL(s(X), cons(Y, ng(X'''))) -> SEL(X, g(X'''))
no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar
           →DP Problem 15
Nar
             ...
               →DP Problem 19
Argument Filtering and Ordering


Dependency Pairs:

SEL(s(s(X'')), cons(Y, cons(Y'', ng(ng(X'''''))))) -> SEL(s(X''), cons(Y'', ng(ng(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(nf(X'''''))))) -> SEL(s(X''), cons(Y'', ng(nf(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(ng(X'''''))))) -> SEL(s(X''), cons(Y'', nf(ng(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(nf(X'''''))))) -> SEL(s(X''), cons(Y'', nf(nf(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(X''''')))) -> SEL(s(X''), cons(Y'', nf(X''''')))
SEL(s(s(X'')), cons(Y, cons(Y'', Z'''))) -> SEL(s(X''), cons(Y'', Z'''))
SEL(s(X), cons(Y, ng(ng(X''')))) -> SEL(X, g(g(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, f(X'''))
SEL(s(X), cons(Y, nf(nf(X''')))) -> SEL(X, f(f(activate(X'''))))
SEL(s(X), cons(Y, nf(ng(X''')))) -> SEL(X, f(g(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, cons(activate(X'''), nf(ng(activate(X''')))))
SEL(s(X), cons(Y, ng(nf(X''')))) -> SEL(X, g(f(activate(X'''))))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(X''''')))) -> SEL(s(X''), cons(Y'', ng(X''''')))


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




The following dependency pairs can be strictly oriented:

SEL(s(s(X'')), cons(Y, cons(Y'', ng(ng(X'''''))))) -> SEL(s(X''), cons(Y'', ng(ng(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(nf(X'''''))))) -> SEL(s(X''), cons(Y'', ng(nf(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(ng(X'''''))))) -> SEL(s(X''), cons(Y'', nf(ng(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(nf(X'''''))))) -> SEL(s(X''), cons(Y'', nf(nf(X'''''))))
SEL(s(s(X'')), cons(Y, cons(Y'', nf(X''''')))) -> SEL(s(X''), cons(Y'', nf(X''''')))
SEL(s(s(X'')), cons(Y, cons(Y'', Z'''))) -> SEL(s(X''), cons(Y'', Z'''))
SEL(s(X), cons(Y, ng(ng(X''')))) -> SEL(X, g(g(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, f(X'''))
SEL(s(X), cons(Y, nf(nf(X''')))) -> SEL(X, f(f(activate(X'''))))
SEL(s(X), cons(Y, nf(ng(X''')))) -> SEL(X, f(g(activate(X'''))))
SEL(s(X), cons(Y, nf(X'''))) -> SEL(X, cons(activate(X'''), nf(ng(activate(X''')))))
SEL(s(X), cons(Y, ng(nf(X''')))) -> SEL(X, g(f(activate(X'''))))
SEL(s(s(X'')), cons(Y, cons(Y'', ng(X''''')))) -> SEL(s(X''), cons(Y'', ng(X''''')))


There are no usable rules for innermost w.r.t. to the AFS that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
SEL(x1, x2) -> x1
s(x1) -> s(x1)


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
Nar
           →DP Problem 15
Nar
             ...
               →DP Problem 20
Dependency Graph


Dependency Pair:


Rules:


f(X) -> cons(X, nf(ng(X)))
f(X) -> nf(X)
g(0) -> s(0)
g(s(X)) -> s(s(g(X)))
g(X) -> ng(X)
sel(0, cons(X, Y)) -> X
sel(s(X), cons(Y, Z)) -> sel(X, activate(Z))
activate(nf(X)) -> f(activate(X))
activate(ng(X)) -> g(activate(X))
activate(X) -> X


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.

Innermost Termination of R successfully shown.
Duration:
0:10 minutes