Term Rewriting System R:
[X]
active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))

Innermost Termination of R to be shown.



   R
Dependency Pair Analysis



R contains the following Dependency Pairs:

ACTIVE(c) -> F(g(c))
ACTIVE(c) -> G(c)
PROPER(f(X)) -> F(proper(X))
PROPER(f(X)) -> PROPER(X)
PROPER(g(X)) -> G(proper(X))
PROPER(g(X)) -> PROPER(X)
F(ok(X)) -> F(X)
G(ok(X)) -> G(X)
TOP(mark(X)) -> TOP(proper(X))
TOP(mark(X)) -> PROPER(X)
TOP(ok(X)) -> TOP(active(X))
TOP(ok(X)) -> ACTIVE(X)

Furthermore, R contains four SCCs.


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


Dependency Pair:

F(ok(X)) -> F(X)


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

F(ok(X)) -> F(X)
one new Dependency Pair is created:

F(ok(ok(X''))) -> F(ok(X''))

The transformation is resulting in one new DP problem:



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


Dependency Pair:

F(ok(ok(X''))) -> F(ok(X''))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

F(ok(ok(X''))) -> F(ok(X''))
one new Dependency Pair is created:

F(ok(ok(ok(X'''')))) -> F(ok(ok(X'''')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
           →DP Problem 5
FwdInst
             ...
               →DP Problem 6
Polynomial Ordering
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar


Dependency Pair:

F(ok(ok(ok(X'''')))) -> F(ok(ok(X'''')))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




The following dependency pair can be strictly oriented:

F(ok(ok(ok(X'''')))) -> F(ok(ok(X'''')))


There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(ok(x1))=  1 + x1  
  POL(F(x1))=  1 + x1  

resulting in one new DP problem.



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


Dependency Pair:


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(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
FwdInst
       →DP Problem 4
Nar


Dependency Pair:

G(ok(X)) -> G(X)


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

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

G(ok(ok(X''))) -> G(ok(X''))

The transformation is resulting in one new DP problem:



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


Dependency Pair:

G(ok(ok(X''))) -> G(ok(X''))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

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

G(ok(ok(ok(X'''')))) -> G(ok(ok(X'''')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
           →DP Problem 8
FwdInst
             ...
               →DP Problem 9
Polynomial Ordering
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar


Dependency Pair:

G(ok(ok(ok(X'''')))) -> G(ok(ok(X'''')))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




The following dependency pair can be strictly oriented:

G(ok(ok(ok(X'''')))) -> G(ok(ok(X'''')))


There are no usable rules for innermost that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(G(x1))=  1 + x1  
  POL(ok(x1))=  1 + x1  

resulting in one new DP problem.



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


Dependency Pair:


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(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
Forward Instantiation Transformation
       →DP Problem 4
Nar


Dependency Pairs:

PROPER(g(X)) -> PROPER(X)
PROPER(f(X)) -> PROPER(X)


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

PROPER(f(X)) -> PROPER(X)
two new Dependency Pairs are created:

PROPER(f(f(X''))) -> PROPER(f(X''))
PROPER(f(g(X''))) -> PROPER(g(X''))

The transformation is resulting in one new DP problem:



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


Dependency Pairs:

PROPER(f(g(X''))) -> PROPER(g(X''))
PROPER(f(f(X''))) -> PROPER(f(X''))
PROPER(g(X)) -> PROPER(X)


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

PROPER(g(X)) -> PROPER(X)
three new Dependency Pairs are created:

PROPER(g(g(X''))) -> PROPER(g(X''))
PROPER(g(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(f(g(X'''')))) -> PROPER(f(g(X'''')))

The transformation is resulting in one new DP problem:



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


Dependency Pairs:

PROPER(g(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(f(f(X''))) -> PROPER(f(X''))
PROPER(g(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(g(X''))) -> PROPER(g(X''))
PROPER(f(g(X''))) -> PROPER(g(X''))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

PROPER(f(f(X''))) -> PROPER(f(X''))
two new Dependency Pairs are created:

PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(f(f(g(X'''')))) -> PROPER(f(g(X'''')))

The transformation is resulting in one new DP problem:



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


Dependency Pairs:

PROPER(f(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(g(X''))) -> PROPER(g(X''))
PROPER(f(g(X''))) -> PROPER(g(X''))
PROPER(g(f(g(X'''')))) -> PROPER(f(g(X'''')))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

PROPER(f(g(X''))) -> PROPER(g(X''))
three new Dependency Pairs are created:

PROPER(f(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(f(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(f(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))

The transformation is resulting in one new DP problem:



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


Dependency Pairs:

PROPER(f(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))
PROPER(f(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(g(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(g(X''))) -> PROPER(g(X''))
PROPER(f(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(f(f(g(X'''')))) -> PROPER(f(g(X'''')))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

PROPER(g(g(X''))) -> PROPER(g(X''))
three new Dependency Pairs are created:

PROPER(g(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(g(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(g(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))

The transformation is resulting in one new DP problem:



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


Dependency Pairs:

PROPER(g(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))
PROPER(f(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(f(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(g(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(f(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(g(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(f(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

PROPER(g(f(f(X'''')))) -> PROPER(f(f(X'''')))
two new Dependency Pairs are created:

PROPER(g(f(f(f(X''''''))))) -> PROPER(f(f(f(X''''''))))
PROPER(g(f(f(g(X''''''))))) -> PROPER(f(f(g(X''''''))))

The transformation is resulting in one new DP problem:



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


Dependency Pairs:

PROPER(f(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))
PROPER(g(f(f(g(X''''''))))) -> PROPER(f(f(g(X''''''))))
PROPER(f(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(f(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(f(f(f(X''''''))))) -> PROPER(f(f(f(X''''''))))
PROPER(g(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(g(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(f(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(g(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(g(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

PROPER(g(f(g(X'''')))) -> PROPER(f(g(X'''')))
three new Dependency Pairs are created:

PROPER(g(f(g(g(X''''''))))) -> PROPER(f(g(g(X''''''))))
PROPER(g(f(g(f(f(X'''''''')))))) -> PROPER(f(g(f(f(X'''''''')))))
PROPER(g(f(g(f(g(X'''''''')))))) -> PROPER(f(g(f(g(X'''''''')))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
           →DP Problem 11
FwdInst
             ...
               →DP Problem 17
Polynomial Ordering
       →DP Problem 4
Nar


Dependency Pairs:

PROPER(g(f(g(f(g(X'''''''')))))) -> PROPER(f(g(f(g(X'''''''')))))
PROPER(g(f(g(f(f(X'''''''')))))) -> PROPER(f(g(f(f(X'''''''')))))
PROPER(g(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))
PROPER(g(f(f(g(X''''''))))) -> PROPER(f(f(g(X''''''))))
PROPER(f(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(f(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(g(f(f(f(X''''''))))) -> PROPER(f(f(f(X''''''))))
PROPER(g(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(g(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(f(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(g(f(g(g(X''''''))))) -> PROPER(f(g(g(X''''''))))
PROPER(f(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

PROPER(g(f(g(f(g(X'''''''')))))) -> PROPER(f(g(f(g(X'''''''')))))
PROPER(g(f(g(f(f(X'''''''')))))) -> PROPER(f(g(f(f(X'''''''')))))
PROPER(g(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))
PROPER(g(f(f(g(X''''''))))) -> PROPER(f(f(g(X''''''))))
PROPER(g(f(f(f(X''''''))))) -> PROPER(f(f(f(X''''''))))
PROPER(g(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(g(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(g(f(g(g(X''''''))))) -> PROPER(f(g(g(X''''''))))


Additionally, the following usable rules for innermost can be oriented:

f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(g(x1))=  1 + x1  
  POL(PROPER(x1))=  1 + x1  
  POL(ok(x1))=  0  
  POL(f(x1))=  x1  

resulting in one new DP problem.



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


Dependency Pairs:

PROPER(f(g(f(f(X''''''))))) -> PROPER(g(f(f(X''''''))))
PROPER(f(f(g(X'''')))) -> PROPER(f(g(X'''')))
PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))
PROPER(f(g(g(X'''')))) -> PROPER(g(g(X'''')))
PROPER(f(g(f(g(X''''''))))) -> PROPER(g(f(g(X''''''))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




Using the Dependency Graph the DP problem was split into 1 DP problems.


   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
           →DP Problem 11
FwdInst
             ...
               →DP Problem 19
Polynomial Ordering
       →DP Problem 4
Nar


Dependency Pair:

PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




The following dependency pair can be strictly oriented:

PROPER(f(f(f(X'''')))) -> PROPER(f(f(X'''')))


Additionally, the following usable rule for innermost can be oriented:

f(ok(X)) -> ok(f(X))


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(PROPER(x1))=  1 + x1  
  POL(ok(x1))=  0  
  POL(f(x1))=  1 + x1  

resulting in one new DP problem.



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


Dependency Pair:


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(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
FwdInst
       →DP Problem 4
Narrowing Transformation


Dependency Pairs:

TOP(ok(X)) -> TOP(active(X))
TOP(mark(X)) -> TOP(proper(X))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(X)) -> TOP(proper(X))
three new Dependency Pairs are created:

TOP(mark(c)) -> TOP(ok(c))
TOP(mark(f(X''))) -> TOP(f(proper(X'')))
TOP(mark(g(X''))) -> TOP(g(proper(X'')))

The transformation is resulting in one new DP problem:



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


Dependency Pairs:

TOP(mark(g(X''))) -> TOP(g(proper(X'')))
TOP(mark(f(X''))) -> TOP(f(proper(X'')))
TOP(mark(c)) -> TOP(ok(c))
TOP(ok(X)) -> TOP(active(X))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(ok(X)) -> TOP(active(X))
two new Dependency Pairs are created:

TOP(ok(c)) -> TOP(mark(f(g(c))))
TOP(ok(f(g(X'')))) -> TOP(mark(g(X'')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 22
Narrowing Transformation


Dependency Pairs:

TOP(ok(f(g(X'')))) -> TOP(mark(g(X'')))
TOP(mark(f(X''))) -> TOP(f(proper(X'')))
TOP(ok(c)) -> TOP(mark(f(g(c))))
TOP(mark(c)) -> TOP(ok(c))
TOP(mark(g(X''))) -> TOP(g(proper(X'')))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(f(X''))) -> TOP(f(proper(X'')))
three new Dependency Pairs are created:

TOP(mark(f(c))) -> TOP(f(ok(c)))
TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))
TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 23
Rewriting Transformation


Dependency Pairs:

TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))
TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))
TOP(mark(f(c))) -> TOP(f(ok(c)))
TOP(ok(c)) -> TOP(mark(f(g(c))))
TOP(mark(c)) -> TOP(ok(c))
TOP(mark(g(X''))) -> TOP(g(proper(X'')))
TOP(ok(f(g(X'')))) -> TOP(mark(g(X'')))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(f(c))) -> TOP(f(ok(c)))
one new Dependency Pair is created:

TOP(mark(f(c))) -> TOP(ok(f(c)))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 24
Narrowing Transformation


Dependency Pairs:

TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))
TOP(ok(f(g(X'')))) -> TOP(mark(g(X'')))
TOP(mark(g(X''))) -> TOP(g(proper(X'')))
TOP(ok(c)) -> TOP(mark(f(g(c))))
TOP(mark(c)) -> TOP(ok(c))
TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(g(X''))) -> TOP(g(proper(X'')))
three new Dependency Pairs are created:

TOP(mark(g(c))) -> TOP(g(ok(c)))
TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))
TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 25
Rewriting Transformation


Dependency Pairs:

TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))
TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))
TOP(mark(g(c))) -> TOP(g(ok(c)))
TOP(ok(f(g(X'')))) -> TOP(mark(g(X'')))
TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))
TOP(ok(c)) -> TOP(mark(f(g(c))))
TOP(mark(c)) -> TOP(ok(c))
TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(g(c))) -> TOP(g(ok(c)))
one new Dependency Pair is created:

TOP(mark(g(c))) -> TOP(ok(g(c)))

The transformation is resulting in one new DP problem:



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


Dependency Pairs:

TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))
TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))
TOP(ok(f(g(X'')))) -> TOP(mark(g(X'')))
TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))
TOP(ok(c)) -> TOP(mark(f(g(c))))
TOP(mark(c)) -> TOP(ok(c))
TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(ok(f(g(X'')))) -> TOP(mark(g(X'')))
two new Dependency Pairs are created:

TOP(ok(f(g(f(X''''))))) -> TOP(mark(g(f(X''''))))
TOP(ok(f(g(g(X''''))))) -> TOP(mark(g(g(X''''))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 27
Polynomial Ordering


Dependency Pairs:

TOP(ok(f(g(g(X''''))))) -> TOP(mark(g(g(X''''))))
TOP(ok(f(g(f(X''''))))) -> TOP(mark(g(f(X''''))))
TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))
TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))
TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))
TOP(ok(c)) -> TOP(mark(f(g(c))))
TOP(mark(c)) -> TOP(ok(c))
TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




The following dependency pair can be strictly oriented:

TOP(mark(c)) -> TOP(ok(c))


Additionally, the following usable rules for innermost can be oriented:

g(ok(X)) -> ok(g(X))
f(ok(X)) -> ok(f(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(proper(x1))=  0  
  POL(c)=  1  
  POL(g(x1))=  0  
  POL(mark(x1))=  x1  
  POL(ok(x1))=  0  
  POL(TOP(x1))=  x1  
  POL(f(x1))=  0  

resulting in one new DP problem.



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 28
Polynomial Ordering


Dependency Pairs:

TOP(ok(f(g(g(X''''))))) -> TOP(mark(g(g(X''''))))
TOP(ok(f(g(f(X''''))))) -> TOP(mark(g(f(X''''))))
TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))
TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))
TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))
TOP(ok(c)) -> TOP(mark(f(g(c))))
TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




The following dependency pair can be strictly oriented:

TOP(ok(c)) -> TOP(mark(f(g(c))))


Additionally, the following usable rules for innermost can be oriented:

g(ok(X)) -> ok(g(X))
f(ok(X)) -> ok(f(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(proper(x1))=  x1  
  POL(c)=  1  
  POL(g(x1))=  0  
  POL(mark(x1))=  0  
  POL(ok(x1))=  x1  
  POL(TOP(x1))=  x1  
  POL(f(x1))=  0  

resulting in one new DP problem.



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
FwdInst
       →DP Problem 3
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 29
Polynomial Ordering


Dependency Pairs:

TOP(ok(f(g(g(X''''))))) -> TOP(mark(g(g(X''''))))
TOP(ok(f(g(f(X''''))))) -> TOP(mark(g(f(X''''))))
TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))
TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))
TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))
TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

TOP(ok(f(g(g(X''''))))) -> TOP(mark(g(g(X''''))))
TOP(ok(f(g(f(X''''))))) -> TOP(mark(g(f(X''''))))


Additionally, the following usable rules for innermost can be oriented:

g(ok(X)) -> ok(g(X))
f(ok(X)) -> ok(f(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(proper(x1))=  x1  
  POL(c)=  0  
  POL(g(x1))=  0  
  POL(mark(x1))=  x1  
  POL(ok(x1))=  x1  
  POL(TOP(x1))=  x1  
  POL(f(x1))=  1  

resulting in one new DP problem.



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


Dependency Pairs:

TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))
TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))
TOP(mark(f(f(X')))) -> TOP(f(f(proper(X'))))
TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(f(f(X')))) -> TOP(f(f(proper(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
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 31
Forward Instantiation Transformation


Dependency Pairs:

TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))
TOP(mark(f(g(X')))) -> TOP(f(g(proper(X'))))
TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(f(g(X')))) -> TOP(f(g(proper(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
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 32
Forward Instantiation Transformation


Dependency Pairs:

TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))
TOP(mark(g(f(X')))) -> TOP(g(f(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(g(f(X')))) -> TOP(g(f(proper(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
FwdInst
       →DP Problem 4
Nar
           →DP Problem 21
Nar
             ...
               →DP Problem 33
Forward Instantiation Transformation


Dependency Pair:

TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))


Rules:


active(c) -> mark(f(g(c)))
active(f(g(X))) -> mark(g(X))
proper(c) -> ok(c)
proper(f(X)) -> f(proper(X))
proper(g(X)) -> g(proper(X))
f(ok(X)) -> ok(f(X))
g(ok(X)) -> ok(g(X))
top(mark(X)) -> top(proper(X))
top(ok(X)) -> top(active(X))


Strategy:

innermost




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

TOP(mark(g(g(X')))) -> TOP(g(g(proper(X'))))
no new Dependency Pairs are created.
The transformation is resulting in no new DP problems.


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