Term Rewriting System R:
[x, y, z]
:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e

Innermost Termination of R to be shown. 



   R
     ↳Dependency Pair Analysis



R contains the following Dependency Pairs:

:'(:(x, y), z) -> :'(x, :(z, i(y)))
:'(:(x, y), z) -> :'(z, i(y))
:'(:(x, y), z) -> I(y)
:'(e, x) -> I(x)
:'(x, :(y, i(x))) -> I(y)
:'(x, :(y, :(i(x), z))) -> :'(i(z), y)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(i(x), :(y, x)) -> I(y)
:'(i(x), :(y, :(x, z))) -> :'(i(z), y)
:'(i(x), :(y, :(x, z))) -> I(z)
I(:(x, y)) -> :'(y, x)

Furthermore, R contains one SCC. 


   R
     ↳DPs
       →DP Problem 1
         ↳Narrowing Transformation


Dependency Pairs:

:'(i(x), :(y, :(x, z))) -> I(z)
:'(i(x), :(y, :(x, z))) -> :'(i(z), y)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(e, x) -> I(x)
I(:(x, y)) -> :'(y, x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
:'(x, :(y, :(i(x), z))) -> :'(i(z), y)
:'(:(x, y), z) -> :'(x, :(z, i(y)))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(:(x, y), z) -> :'(x, :(z, i(y)))
five new Dependency Pairs are created:

:'(:(x, y'), i(y')) -> :'(x, e)
:'(:(x, y0), :(x'', y'')) -> :'(x, :(x'', :(i(y0), i(y''))))
:'(:(x, y'), e) -> :'(x, i(i(y')))
:'(:(x, :(x'', y'')), z) -> :'(x, :(z, :(y'', x'')))
:'(:(x, i(x'')), z) -> :'(x, :(z, x''))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Narrowing Transformation


Dependency Pairs:

:'(:(x, y'), e) -> :'(x, i(i(y')))
:'(:(x, y0), :(x'', y'')) -> :'(x, :(x'', :(i(y0), i(y''))))
:'(:(x, i(x'')), z) -> :'(x, :(z, x''))
:'(i(x), :(y, :(x, z))) -> :'(i(z), y)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, :(x'', y'')), z) -> :'(x, :(z, :(y'', x'')))
:'(x, :(y, :(i(x), z))) -> :'(i(z), y)
:'(e, x) -> I(x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(i(x), :(y, :(x, z))) -> I(z)


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(x, :(y, :(i(x), z))) -> :'(i(z), y)
two new Dependency Pairs are created:

:'(x, :(y, :(i(x), :(x'', y'')))) -> :'(:(y'', x''), y)
:'(x, :(y, :(i(x), i(x'')))) -> :'(x'', y)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 3
                 ↳Narrowing Transformation


Dependency Pairs:

:'(:(x, y0), :(x'', y'')) -> :'(x, :(x'', :(i(y0), i(y''))))
:'(:(x, i(x'')), z) -> :'(x, :(z, x''))
:'(x, :(y, :(i(x), :(x'', y'')))) -> :'(:(y'', x''), y)
:'(i(x), :(y, :(x, z))) -> I(z)
:'(:(x, :(x'', y'')), z) -> :'(x, :(z, :(y'', x'')))
:'(i(x), :(y, :(x, z))) -> :'(i(z), y)
:'(e, x) -> I(x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, y'), e) -> :'(x, i(i(y')))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(i(x), :(y, :(x, z))) -> :'(i(z), y)
two new Dependency Pairs are created:

:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(i(x), :(y, :(x, i(x'')))) -> :'(x'', y)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 4
                 ↳Narrowing Transformation


Dependency Pairs:

:'(:(x, i(x'')), z) -> :'(x, :(z, x''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, :(x'', y'')), z) -> :'(x, :(z, :(y'', x'')))
:'(x, :(y, :(i(x), :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, y'), e) -> :'(x, i(i(y')))
:'(i(x), :(y, :(x, z))) -> I(z)
:'(e, x) -> I(x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, y0), :(x'', y'')) -> :'(x, :(x'', :(i(y0), i(y''))))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(:(x, y0), :(x'', y'')) -> :'(x, :(x'', :(i(y0), i(y''))))
five new Dependency Pairs are created:

:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 5
                 ↳Narrowing Transformation


Dependency Pairs:

:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, :(x'', y'')), z) -> :'(x, :(z, :(y'', x'')))
:'(x, :(y, :(i(x), :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, y'), e) -> :'(x, i(i(y')))
:'(i(x), :(y, :(x, z))) -> I(z)
:'(e, x) -> I(x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, i(x'')), z) -> :'(x, :(z, x''))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(:(x, y'), e) -> :'(x, i(i(y')))
three new Dependency Pairs are created:

:'(:(x, y''), e) -> :'(x, y'')
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, i(x'')), e) -> :'(x, i(x''))

The transformation is resulting in one new DP problem: 



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


Dependency Pairs:

:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, i(x'')), z) -> :'(x, :(z, x''))
:'(x, :(y, :(i(x), :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, :(x'', y'')), z) -> :'(x, :(z, :(y'', x'')))
:'(i(x), :(y, :(x, z))) -> I(z)
:'(e, x) -> I(x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(:(x, :(x'', y'')), z) -> :'(x, :(z, :(y'', x'')))
six new Dependency Pairs are created:

:'(:(x, :(x''', y''')), :(y''', x''')) -> :'(x, e)
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))

The transformation is resulting in one new DP problem: 



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


Dependency Pairs:

:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, i(x'')), z) -> :'(x, :(z, x''))
:'(i(x), :(y, :(x, z))) -> I(z)
:'(e, x) -> I(x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(:(x, i(x'')), z) -> :'(x, :(z, x''))
three new Dependency Pairs are created:

:'(:(x, i(x''')), x''') -> :'(x, e)
:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))
:'(:(x, i(x''')), e) -> :'(x, i(x'''))

The transformation is resulting in one new DP problem: 



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


Dependency Pairs:

:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x'', y'')))) -> :'(:(y'', x''), y)
:'(i(x), :(y, :(x, z))) -> I(z)
:'(e, x) -> I(x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(x, :(y, :(i(x), :(x'', y'')))) -> :'(:(y'', x''), y)
one new Dependency Pair is created:

:'(x, :(y, :(i(x), :(x''', :(x'0, y'''))))) -> :'(:(x'0, :(x''', i(y'''))), y)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 9
                 ↳Forward Instantiation Transformation


Dependency Pairs:

:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x''', :(x'0, y'''))))) -> :'(:(x'0, :(x''', i(y'''))), y)
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(i(x), :(y, :(x, z))) -> I(z)
:'(e, x) -> I(x)
:'(:(x, y), z) -> I(y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(:(x, y), z) -> I(y)
one new Dependency Pair is created:

:'(:(x, :(x'', y'')), z) -> I(:(x'', y''))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 10
                 ↳Forward Instantiation Transformation


Dependency Pairs:

:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x'', y'')), z) -> I(:(x'', y''))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x''', :(x'0, y'''))))) -> :'(:(x'0, :(x''', i(y'''))), y)
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(i(x), :(y, :(x, z))) -> I(z)
:'(e, x) -> I(x)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(e, x) -> I(x)
one new Dependency Pair is created:

:'(e, :(x'', y'')) -> I(:(x'', y''))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 11
                 ↳Forward Instantiation Transformation


Dependency Pairs:

:'(e, :(x'', y'')) -> I(:(x'', y''))
:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x'', y'')), z) -> I(:(x'', y''))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x''', :(x'0, y'''))))) -> :'(:(x'0, :(x''', i(y'''))), y)
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(i(x), :(y, :(x, z))) -> I(z)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), z))) -> I(z)
:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(x, :(y, :(i(x), z))) -> I(z)
one new Dependency Pair is created:

:'(x, :(y, :(i(x), :(x'', y'')))) -> I(:(x'', y''))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 12
                 ↳Forward Instantiation Transformation


Dependency Pairs:

:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))
:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x'', y'')), z) -> I(:(x'', y''))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
:'(x, :(y, :(i(x), :(x'', y'')))) -> I(:(x'', y''))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x''', :(x'0, y'''))))) -> :'(:(x'0, :(x''', i(y'''))), y)
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(i(x), :(y, :(x, z))) -> I(z)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x, y)) -> :'(y, x)
:'(e, :(x'', y'')) -> I(:(x'', y''))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

:'(i(x), :(y, :(x, z))) -> I(z)
one new Dependency Pair is created:

:'(i(x), :(y, :(x, :(x'', y'')))) -> I(:(x'', y''))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 13
                 ↳Forward Instantiation Transformation


Dependency Pairs:

:'(e, :(x'', y'')) -> I(:(x'', y''))
:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(:(x, :(x'', y'')), z) -> I(:(x'', y''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> I(:(x'', y''))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
I(:(x, y)) -> :'(y, x)
:'(x, :(y, :(i(x), :(x'', y'')))) -> I(:(x'', y''))
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x''', :(x'0, y'''))))) -> :'(:(x'0, :(x''', i(y'''))), y)
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, y), z) -> :'(z, i(y))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




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

I(:(x, y)) -> :'(y, x)
three new Dependency Pairs are created:

I(:(x0, :(x'', y''))) -> :'(:(x'', y''), x0)
I(:(x0, :(x'', :(x''''', :(x'0'', y'''))))) -> :'(:(x'', :(x''''', :(x'0'', y'''))), x0)
I(:(x0, :(x'', :(x'''', y'''')))) -> :'(:(x'', :(x'''', y'''')), x0)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 14
                 ↳Argument Filtering and Ordering


Dependency Pairs:

:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))
:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x'', y'')), z) -> I(:(x'', y''))
I(:(x0, :(x'', :(x'''', y'''')))) -> :'(:(x'', :(x'''', y'''')), x0)
:'(i(x), :(y, :(x, :(x'', y'')))) -> I(:(x'', y''))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
I(:(x0, :(x'', :(x''''', :(x'0'', y'''))))) -> :'(:(x'', :(x''''', :(x'0'', y'''))), x0)
:'(x, :(y, :(i(x), :(x'', y'')))) -> I(:(x'', y''))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x''', :(x'0, y'''))))) -> :'(:(x'0, :(x''', i(y'''))), y)
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x0, :(x'', y''))) -> :'(:(x'', y''), x0)
:'(e, :(x'', y'')) -> I(:(x'', y''))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




The following dependency pairs can be strictly oriented:

:'(:(x, :(x''', y''')), e) -> :'(x, i(:(y''', x''')))
:'(:(x, :(x'', y'')), e) -> :'(x, i(:(y'', x'')))
:'(:(x, y'''), :(x'', y''')) -> :'(x, :(x'', e))
:'(:(x, :(x'', y'')), z) -> I(:(x'', y''))
I(:(x0, :(x'', :(x'''', y'''')))) -> :'(:(x'', :(x'''', y'''')), x0)
:'(i(x), :(y, :(x, :(x'', y'')))) -> I(:(x'', y''))
I(:(x0, :(x'', :(x''''', :(x'0'', y'''))))) -> :'(:(x'', :(x''''', :(x'0'', y'''))), x0)
:'(x, :(y, :(i(x), :(x'', y'')))) -> I(:(x'', y''))
:'(:(x, :(x''', y''')), i(x''')) -> :'(x, i(y'''))
:'(x, :(y, :(i(x), :(x''', :(x'0, y'''))))) -> :'(:(x'0, :(x''', i(y'''))), y)
:'(:(x, :(i(z'), y''')), z') -> :'(x, i(y'''))
:'(i(x), :(y, :(x, :(x'', y'')))) -> :'(:(y'', x''), y)
:'(:(x, y), z) -> :'(z, i(y))
I(:(x0, :(x'', y''))) -> :'(:(x'', y''), x0)


The following usable rules for innermost w.r.t. to the AFS can be oriented:

:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Used ordering: Polynomial ordering with Polynomial interpretation:
  POL(:(x1, x2))=  1 + x1 + x2  
  POL(I(x1))=  x1  
  POL(i(x1))=  x1  
  POL(e)=  0  
  POL(:'(x1, x2))=  x1 + x2  

resulting in one new DP problem.
Used Argument Filtering System:
:'(x1, x2) -> :'(x1, x2)
:(x1, x2) -> :(x1, x2)
i(x1) -> i(x1)
I(x1) -> I(x1)


   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 15
                 ↳Dependency Graph


Dependency Pairs:

:'(:(x, i(x''')), :(x'0, y')) -> :'(x, :(x'0, :(x''', i(y'))))
:'(:(x, :(x''', y''')), :(x'0, y')) -> :'(x, :(x'0, :(:(y''', x'''), i(y'))))
:'(:(x, y0), :(x'', i(x'''))) -> :'(x, :(x'', :(i(y0), x''')))
:'(:(x, y0), :(x'', :(x''', y'))) -> :'(x, :(x'', :(i(y0), :(y', x'''))))
:'(:(x, i(x''')), :(x'', y'')) -> :'(x, :(x'', :(x''', i(y''))))
:'(:(x, :(x''', y')), :(x'', y'')) -> :'(x, :(x'', :(:(y', x'''), i(y''))))
:'(:(x, :(x''', :(x'0, y'))), z) -> :'(x, :(z, :(x'0, :(x''', i(y')))))
:'(e, :(x'', y'')) -> I(:(x'', y''))


Rules:


:(x, x) -> e
:(x, e) -> x
:(:(x, y), z) -> :(x, :(z, i(y)))
:(e, x) -> i(x)
:(x, :(y, i(x))) -> i(y)
:(x, :(y, :(i(x), z))) -> :(i(z), y)
:(i(x), :(y, x)) -> i(y)
:(i(x), :(y, :(x, z))) -> :(i(z), y)
i(:(x, y)) -> :(y, x)
i(i(x)) -> x
i(e) -> e


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.

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