Term Rewriting System R:
[Y, U, V, X, W, Z]
concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))

Innermost Termination of R to be shown.



   R
Dependency Pair Analysis



R contains the following Dependency Pairs:

CONCAT(cons(U, V), Y) -> CONCAT(V, Y)
LESSLEAVES(cons(U, V), cons(W, Z)) -> LESSLEAVES(concat(U, V), concat(W, Z))
LESSLEAVES(cons(U, V), cons(W, Z)) -> CONCAT(U, V)
LESSLEAVES(cons(U, V), cons(W, Z)) -> CONCAT(W, Z)

Furthermore, R contains two SCCs.


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


Dependency Pair:

CONCAT(cons(U, V), Y) -> CONCAT(V, Y)


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




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

CONCAT(cons(U, V), Y) -> CONCAT(V, Y)
one new Dependency Pair is created:

CONCAT(cons(U, cons(U'', V'')), Y'') -> CONCAT(cons(U'', V''), Y'')

The transformation is resulting in one new DP problem:



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


Dependency Pair:

CONCAT(cons(U, cons(U'', V'')), Y'') -> CONCAT(cons(U'', V''), Y'')


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




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

CONCAT(cons(U, cons(U'', V'')), Y'') -> CONCAT(cons(U'', V''), Y'')
one new Dependency Pair is created:

CONCAT(cons(U, cons(U'''', cons(U''''', V''''))), Y'''') -> CONCAT(cons(U'''', cons(U''''', V'''')), Y'''')

The transformation is resulting in one new DP problem:



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


Dependency Pair:

CONCAT(cons(U, cons(U'''', cons(U''''', V''''))), Y'''') -> CONCAT(cons(U'''', cons(U''''', V'''')), Y'''')


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




The following dependency pair can be strictly oriented:

CONCAT(cons(U, cons(U'''', cons(U''''', V''''))), Y'''') -> CONCAT(cons(U'''', cons(U''''', V'''')), Y'''')


There are no usable rules for innermost that need to be oriented.
Used ordering: Lexicographic Path Order with Non-Strict Precedence with Quasi Precedence:
trivial

resulting in one new DP problem.
Used Argument Filtering System:
CONCAT(x1, x2) -> CONCAT(x1, x2)
cons(x1, x2) -> cons(x1, x2)


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


Dependency Pair:


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


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


Dependency Pair:

LESSLEAVES(cons(U, V), cons(W, Z)) -> LESSLEAVES(concat(U, V), concat(W, Z))


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




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

LESSLEAVES(cons(U, V), cons(W, Z)) -> LESSLEAVES(concat(U, V), concat(W, Z))
four new Dependency Pairs are created:

LESSLEAVES(cons(leaf, V'), cons(W, Z)) -> LESSLEAVES(V', concat(W, Z))
LESSLEAVES(cons(cons(U'', V''), V0), cons(W, Z)) -> LESSLEAVES(cons(U'', concat(V'', V0)), concat(W, Z))
LESSLEAVES(cons(U, V), cons(leaf, Z')) -> LESSLEAVES(concat(U, V), Z')
LESSLEAVES(cons(U, V), cons(cons(U'', V''), Z')) -> LESSLEAVES(concat(U, V), cons(U'', concat(V'', Z')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 6
Narrowing Transformation


Dependency Pairs:

LESSLEAVES(cons(U, V), cons(cons(U'', V''), Z')) -> LESSLEAVES(concat(U, V), cons(U'', concat(V'', Z')))
LESSLEAVES(cons(U, V), cons(leaf, Z')) -> LESSLEAVES(concat(U, V), Z')
LESSLEAVES(cons(cons(U'', V''), V0), cons(W, Z)) -> LESSLEAVES(cons(U'', concat(V'', V0)), concat(W, Z))
LESSLEAVES(cons(leaf, V'), cons(W, Z)) -> LESSLEAVES(V', concat(W, Z))


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




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

LESSLEAVES(cons(leaf, V'), cons(W, Z)) -> LESSLEAVES(V', concat(W, Z))
two new Dependency Pairs are created:

LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(leaf, V'), cons(cons(U', V''), Z')) -> LESSLEAVES(V', cons(U', concat(V'', Z')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 6
Nar
             ...
               →DP Problem 7
Narrowing Transformation


Dependency Pairs:

LESSLEAVES(cons(leaf, V'), cons(cons(U', V''), Z')) -> LESSLEAVES(V', cons(U', concat(V'', Z')))
LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(U, V), cons(leaf, Z')) -> LESSLEAVES(concat(U, V), Z')
LESSLEAVES(cons(cons(U'', V''), V0), cons(W, Z)) -> LESSLEAVES(cons(U'', concat(V'', V0)), concat(W, Z))
LESSLEAVES(cons(U, V), cons(cons(U'', V''), Z')) -> LESSLEAVES(concat(U, V), cons(U'', concat(V'', Z')))


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




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

LESSLEAVES(cons(cons(U'', V''), V0), cons(W, Z)) -> LESSLEAVES(cons(U'', concat(V'', V0)), concat(W, Z))
four new Dependency Pairs are created:

LESSLEAVES(cons(cons(U'', leaf), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', V0'), concat(W, Z))
LESSLEAVES(cons(cons(U'', cons(U', V')), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', cons(U', concat(V', V0'))), concat(W, Z))
LESSLEAVES(cons(cons(U'', V''), V0), cons(leaf, Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), Z')
LESSLEAVES(cons(cons(U'', V''), V0), cons(cons(U', V'), Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), cons(U', concat(V', Z')))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 6
Nar
             ...
               →DP Problem 8
Narrowing Transformation


Dependency Pairs:

LESSLEAVES(cons(cons(U'', V''), V0), cons(cons(U', V'), Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), cons(U', concat(V', Z')))
LESSLEAVES(cons(cons(U'', V''), V0), cons(leaf, Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), Z')
LESSLEAVES(cons(cons(U'', cons(U', V')), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', cons(U', concat(V', V0'))), concat(W, Z))
LESSLEAVES(cons(cons(U'', leaf), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', V0'), concat(W, Z))
LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(U, V), cons(cons(U'', V''), Z')) -> LESSLEAVES(concat(U, V), cons(U'', concat(V'', Z')))
LESSLEAVES(cons(U, V), cons(leaf, Z')) -> LESSLEAVES(concat(U, V), Z')
LESSLEAVES(cons(leaf, V'), cons(cons(U', V''), Z')) -> LESSLEAVES(V', cons(U', concat(V'', Z')))


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




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

LESSLEAVES(cons(U, V), cons(leaf, Z')) -> LESSLEAVES(concat(U, V), Z')
two new Dependency Pairs are created:

LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(cons(U'', V''), V0), cons(leaf, Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), Z')

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 6
Nar
             ...
               →DP Problem 9
Narrowing Transformation


Dependency Pairs:

LESSLEAVES(cons(cons(U'', V''), V0), cons(leaf, Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), Z')
LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(cons(U'', V''), V0), cons(leaf, Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), Z')
LESSLEAVES(cons(cons(U'', cons(U', V')), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', cons(U', concat(V', V0'))), concat(W, Z))
LESSLEAVES(cons(cons(U'', leaf), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', V0'), concat(W, Z))
LESSLEAVES(cons(leaf, V'), cons(cons(U', V''), Z')) -> LESSLEAVES(V', cons(U', concat(V'', Z')))
LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(U, V), cons(cons(U'', V''), Z')) -> LESSLEAVES(concat(U, V), cons(U'', concat(V'', Z')))
LESSLEAVES(cons(cons(U'', V''), V0), cons(cons(U', V'), Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), cons(U', concat(V', Z')))


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




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

LESSLEAVES(cons(U, V), cons(cons(U'', V''), Z')) -> LESSLEAVES(concat(U, V), cons(U'', concat(V'', Z')))
four new Dependency Pairs are created:

LESSLEAVES(cons(leaf, V'), cons(cons(U'', V''), Z')) -> LESSLEAVES(V', cons(U'', concat(V'', Z')))
LESSLEAVES(cons(cons(U''', V'''), V0), cons(cons(U'', V''), Z')) -> LESSLEAVES(cons(U''', concat(V''', V0)), cons(U'', concat(V'', Z')))
LESSLEAVES(cons(U, V), cons(cons(U'', leaf), Z'')) -> LESSLEAVES(concat(U, V), cons(U'', Z''))
LESSLEAVES(cons(U, V), cons(cons(U'', cons(U''', V''')), Z'')) -> LESSLEAVES(concat(U, V), cons(U'', cons(U''', concat(V''', Z''))))

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
FwdInst
       →DP Problem 2
Nar
           →DP Problem 6
Nar
             ...
               →DP Problem 10
Argument Filtering and Ordering


Dependency Pairs:

LESSLEAVES(cons(U, V), cons(cons(U'', cons(U''', V''')), Z'')) -> LESSLEAVES(concat(U, V), cons(U'', cons(U''', concat(V''', Z''))))
LESSLEAVES(cons(U, V), cons(cons(U'', leaf), Z'')) -> LESSLEAVES(concat(U, V), cons(U'', Z''))
LESSLEAVES(cons(cons(U''', V'''), V0), cons(cons(U'', V''), Z')) -> LESSLEAVES(cons(U''', concat(V''', V0)), cons(U'', concat(V'', Z')))
LESSLEAVES(cons(leaf, V'), cons(cons(U'', V''), Z')) -> LESSLEAVES(V', cons(U'', concat(V'', Z')))
LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(cons(U'', V''), V0), cons(cons(U', V'), Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), cons(U', concat(V', Z')))
LESSLEAVES(cons(cons(U'', V''), V0), cons(leaf, Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), Z')
LESSLEAVES(cons(cons(U'', cons(U', V')), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', cons(U', concat(V', V0'))), concat(W, Z))
LESSLEAVES(cons(cons(U'', leaf), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', V0'), concat(W, Z))
LESSLEAVES(cons(leaf, V'), cons(cons(U', V''), Z')) -> LESSLEAVES(V', cons(U', concat(V'', Z')))
LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(cons(U'', V''), V0), cons(leaf, Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), Z')


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




The following dependency pairs can be strictly oriented:

LESSLEAVES(cons(U, V), cons(cons(U'', cons(U''', V''')), Z'')) -> LESSLEAVES(concat(U, V), cons(U'', cons(U''', concat(V''', Z''))))
LESSLEAVES(cons(U, V), cons(cons(U'', leaf), Z'')) -> LESSLEAVES(concat(U, V), cons(U'', Z''))
LESSLEAVES(cons(cons(U''', V'''), V0), cons(cons(U'', V''), Z')) -> LESSLEAVES(cons(U''', concat(V''', V0)), cons(U'', concat(V'', Z')))
LESSLEAVES(cons(leaf, V'), cons(cons(U'', V''), Z')) -> LESSLEAVES(V', cons(U'', concat(V'', Z')))
LESSLEAVES(cons(leaf, V'), cons(leaf, Z')) -> LESSLEAVES(V', Z')
LESSLEAVES(cons(cons(U'', V''), V0), cons(cons(U', V'), Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), cons(U', concat(V', Z')))
LESSLEAVES(cons(cons(U'', V''), V0), cons(leaf, Z')) -> LESSLEAVES(cons(U'', concat(V'', V0)), Z')
LESSLEAVES(cons(cons(U'', cons(U', V')), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', cons(U', concat(V', V0'))), concat(W, Z))
LESSLEAVES(cons(cons(U'', leaf), V0'), cons(W, Z)) -> LESSLEAVES(cons(U'', V0'), concat(W, Z))
LESSLEAVES(cons(leaf, V'), cons(cons(U', V''), Z')) -> LESSLEAVES(V', cons(U', concat(V'', Z')))


The following usable rules for innermost can be oriented:

concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))


Used ordering: Lexicographic Path Order with Non-Strict Precedence with Quasi Precedence:
{concat, cons}

resulting in one new DP problem.
Used Argument Filtering System:
LESSLEAVES(x1, x2) -> LESSLEAVES(x1, x2)
cons(x1, x2) -> cons(x1, x2)
concat(x1, x2) -> concat(x1, x2)


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


Dependency Pair:


Rules:


concat(leaf, Y) -> Y
concat(cons(U, V), Y) -> cons(U, concat(V, Y))
lessleaves(X, leaf) -> false
lessleaves(leaf, cons(W, Z)) -> true
lessleaves(cons(U, V), cons(W, Z)) -> lessleaves(concat(U, V), concat(W, Z))


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.

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