Termination w.r.t. Q of the given QTRS could be proven:

(0) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

Q is empty.

(1) Overlay + Local Confluence (EQUIVALENT transformation)

The TRS is overlay and locally confluent. By [NOC] we can switch to innermost.

(2) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

(3) DependencyPairsProof (EQUIVALENT transformation)

Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.

(4) Obligation:

Q DP problem:
The TRS P consists of the following rules:

EQ(s(x), s(y)) → EQ(x, y)
UNION(edge(x, y, i), h) → UNION(i, h)
REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
REACH(x, y, i, h) → EQ(x, y)
REACH(x, y, i, h) → ISEMPTY(i)
REACH(x, y, i, h) → EQ(x, from(i))
REACH(x, y, i, h) → FROM(i)
REACH(x, y, i, h) → EQ(y, to(i))
REACH(x, y, i, h) → TO(i)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
IF3(false, b3, x, y, i, h) → REST(i)
IF3(false, b3, x, y, i, h) → FROM(i)
IF3(false, b3, x, y, i, h) → TO(i)
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → OR(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, x, y, i, h) → REST(i)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
IF4(false, x, y, i, h) → TO(i)
IF4(false, x, y, i, h) → UNION(rest(i), h)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.

(5) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 3 SCCs with 13 less nodes.

(6) Complex Obligation (AND)

(7) Obligation:

Q DP problem:
The TRS P consists of the following rules:

UNION(edge(x, y, i), h) → UNION(i, h)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.

(8) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(9) Obligation:

Q DP problem:
The TRS P consists of the following rules:

UNION(edge(x, y, i), h) → UNION(i, h)

R is empty.
The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.

(10) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

(11) Obligation:

Q DP problem:
The TRS P consists of the following rules:

UNION(edge(x, y, i), h) → UNION(i, h)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(12) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• UNION(edge(x, y, i), h) → UNION(i, h)
  The graph contains the following edges 1 > 1, 2 >= 2

(13) TRUE

(14) Obligation:

Q DP problem:
The TRS P consists of the following rules:

EQ(s(x), s(y)) → EQ(x, y)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.

(15) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(16) Obligation:

Q DP problem:
The TRS P consists of the following rules:

EQ(s(x), s(y)) → EQ(x, y)

R is empty.
The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.

(17) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

(18) Obligation:

Q DP problem:
The TRS P consists of the following rules:

EQ(s(x), s(y)) → EQ(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(19) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• EQ(s(x), s(y)) → EQ(x, y)
  The graph contains the following edges 1 > 1, 2 > 2

(20) TRUE

(21) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.

(22) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(23) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.

(24) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

or(true, x0)
or(false, x0)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

(25) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(26) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h) at position [0] we obtained the following new rules [LPAR04]:

REACH(0, 0, y2, y3) → IF1(true, isEmpty(y2), eq(0, from(y2)), eq(0, to(y2)), 0, 0, y2, y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)

(27) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
REACH(0, 0, y2, y3) → IF1(true, isEmpty(y2), eq(0, from(y2)), eq(0, to(y2)), 0, 0, y2, y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(28) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(29) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(30) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty) at position [0] we obtained the following new rules [LPAR04]:

IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(rest(edge(x0, x1, x2)), y3), empty)

(31) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(rest(edge(x0, x1, x2)), y3), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(32) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(rest(edge(x0, x1, x2)), y3), empty) at position [2,0] we obtained the following new rules [LPAR04]:

IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)

(33) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(34) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h) we obtained the following new rules [LPAR04]:

IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)

(35) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(36) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h) we obtained the following new rules [LPAR04]:

IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)

(37) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(38) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h)) we obtained the following new rules [LPAR04]:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))

(39) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(40) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h) we obtained the following new rules [LPAR04]:

IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)

(41) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(42) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF4(false, x, y, i, h) → REACH(x, y, rest(i), h) we obtained the following new rules [LPAR04]:

IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)

(43) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(44) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty) we obtained the following new rules [LPAR04]:

IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)

(45) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(46) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs.

(47) Complex Obligation (AND)

(48) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(49) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2) we obtained the following new rules [LPAR04]:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)

(50) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(51) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3) at position [1] we obtained the following new rules [LPAR04]:

REACH(s(y0), 0, empty, y2) → IF1(false, true, eq(s(y0), from(empty)), eq(0, to(empty)), s(y0), 0, empty, y2)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

(52) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
REACH(s(y0), 0, empty, y2) → IF1(false, true, eq(s(y0), from(empty)), eq(0, to(empty)), s(y0), 0, empty, y2)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(53) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(54) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(55) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(56) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(57) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

isEmpty(empty)
isEmpty(edge(x0, x1, x2))

(58) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(59) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2) at position [2,1] we obtained the following new rules [LPAR04]:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

(60) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(61) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2) at position [3,1] we obtained the following new rules [LPAR04]:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)

(62) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(63) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4)) at position [2] we obtained the following new rules [LPAR04]:

IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF3(false, y0, s(y1), 0, empty, y3) → REACH(s(y1), 0, empty, edge(from(empty), to(empty), y3))

(64) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF3(false, y0, s(y1), 0, empty, y3) → REACH(s(y1), 0, empty, edge(from(empty), to(empty), y3))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(65) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(66) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(67) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3)) at position [3,0] we obtained the following new rules [LPAR04]:

IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3))

(68) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(69) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(70) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(71) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

from(edge(x0, x1, x2))

(72) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(73) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3)) at position [3,1] we obtained the following new rules [LPAR04]:

IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))

(74) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(75) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(76) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(77) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

to(edge(x0, x1, x2))

(78) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(79) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3) at position [2] we obtained the following new rules [LPAR04]:

IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF4(false, s(y0), 0, empty, y2) → REACH(s(y0), 0, empty, y2)

(80) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF4(false, s(y0), 0, empty, y2) → REACH(s(y0), 0, empty, y2)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(81) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(82) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(83) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(84) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(85) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

rest(edge(x0, x1, x2))
rest(empty)

(86) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(87) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty) at position [2] we obtained the following new rules [LPAR04]:

IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

(88) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(89) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5) we obtained the following new rules [LPAR04]:

IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)

(90) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(91) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5) we obtained the following new rules [LPAR04]:

IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)

(92) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(93) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4) we obtained the following new rules [LPAR04]:

IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)

(94) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(95) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3)) we obtained the following new rules [LPAR04]:

IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

(96) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(97) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2) we obtained the following new rules [LPAR04]:

IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)

(98) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(99) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty) we obtained the following new rules [LPAR04]:

IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)

(100) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(101) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6) we obtained the following new rules [LPAR04]:

IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)

(102) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(103) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6) we obtained the following new rules [LPAR04]:

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF3(true, false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5))

(104) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF3(true, false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(105) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₇ + x₈   
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₆ + x₇   
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆   
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅   
POL(REACH(x₁, x₂, x₃, x₄)) = x₃ + x₄   
POL(edge(x₁, x₂, x₃)) = x₂ + x₃   
POL(empty) = 0   
POL(eq(x₁, x₂)) = 0   
POL(false) = 0   
POL(s(x₁)) = 1   
POL(true) = 0   
POL(union(x₁, x₂)) = x₁ + x₂   

The following usable rules [FROCOS05] were oriented:

union(edge(x, y, i), h) → edge(x, y, union(i, h))
union(empty, h) → h

(106) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF3(true, false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(107) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(108) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(109) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 1   
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₃ + x₇ + x₈   
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₂ + x₆ + x₇   
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₄ + x₅ + x₆   
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = 1 + x₄ + x₅   
POL(REACH(x₁, x₂, x₃, x₄)) = x₁ + x₃ + x₄   
POL(edge(x₁, x₂, x₃)) = x₂ + x₃   
POL(empty) = 0   
POL(eq(x₁, x₂)) = 1   
POL(false) = 1   
POL(s(x₁)) = 1   
POL(true) = 1   
POL(union(x₁, x₂)) = x₁ + x₂   

The following usable rules [FROCOS05] were oriented:

eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(s(x), 0) → false
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, s(x)) → false
union(empty, h) → h

(110) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(111) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(112) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(113) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

union(empty, x0)
union(edge(x0, x1, x2), x3)

(114) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.

(115) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
  The graph contains the following edges 1 >= 5, 2 >= 6, 3 >= 7, 4 >= 8

• IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
  The graph contains the following edges 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5

• IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
  The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6, 8 >= 7

• IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
  The graph contains the following edges 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6

• IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
  The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6

• IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
  The graph contains the following edges 2 >= 1, 3 >= 2, 4 > 3, 5 >= 4

• IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
  The graph contains the following edges 3 >= 1, 4 >= 2, 5 > 3

(116) TRUE

(117) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(118) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2) we obtained the following new rules [LPAR04]:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)

(119) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(120) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3) at position [1] we obtained the following new rules [LPAR04]:

REACH(0, s(y0), empty, y2) → IF1(false, true, eq(0, from(empty)), eq(s(y0), to(empty)), 0, s(y0), empty, y2)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)

(121) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
REACH(0, s(y0), empty, y2) → IF1(false, true, eq(0, from(empty)), eq(s(y0), to(empty)), 0, s(y0), empty, y2)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(122) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(123) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(124) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2) at position [2,1] we obtained the following new rules [LPAR04]:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)

(125) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(126) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2) at position [3,1] we obtained the following new rules [LPAR04]:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)

(127) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(128) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4)) at position [2] we obtained the following new rules [LPAR04]:

IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF3(false, y0, 0, s(y1), empty, y3) → REACH(0, s(y1), empty, edge(from(empty), to(empty), y3))

(129) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF3(false, y0, 0, s(y1), empty, y3) → REACH(0, s(y1), empty, edge(from(empty), to(empty), y3))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(130) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(131) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(132) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3)) at position [3,0] we obtained the following new rules [LPAR04]:

IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, to(edge(x0, x1, x2)), y3))

(133) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, to(edge(x0, x1, x2)), y3))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(134) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, to(edge(x0, x1, x2)), y3)) at position [3,1] we obtained the following new rules [LPAR04]:

IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))

(135) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(136) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3) at position [2] we obtained the following new rules [LPAR04]:

IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), empty, y2) → REACH(0, s(y0), empty, y2)

(137) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), empty, y2) → REACH(0, s(y0), empty, y2)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(138) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(139) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(140) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5) we obtained the following new rules [LPAR04]:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)

(141) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(142) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5) we obtained the following new rules [LPAR04]:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)

(143) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(144) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4) we obtained the following new rules [LPAR04]:

IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

(145) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(146) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3) we obtained the following new rules [LPAR04]:

IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)

(147) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(148) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3) at position [1] we obtained the following new rules [LPAR04]:

REACH(s(y0), s(y1), empty, y3) → IF1(eq(y0, y1), true, eq(s(y0), from(empty)), eq(s(y1), to(empty)), s(y0), s(y1), empty, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)

(149) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
REACH(s(y0), s(y1), empty, y3) → IF1(eq(y0, y1), true, eq(s(y0), from(empty)), eq(s(y1), to(empty)), s(y0), s(y1), empty, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(150) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(151) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(152) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(153) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(154) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

isEmpty(empty)
isEmpty(edge(x0, x1, x2))

(155) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(156) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3) at position [2,1] we obtained the following new rules [LPAR04]:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)

(157) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(158) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3) at position [3,1] we obtained the following new rules [LPAR04]:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)

(159) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(160) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty) at position [2] we obtained the following new rules [LPAR04]:

IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)

(161) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(162) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5)) at position [2] we obtained the following new rules [LPAR04]:

IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y4))
IF3(false, y0, s(y1), s(y2), empty, y4) → REACH(s(y1), s(y2), empty, edge(from(empty), to(empty), y4))

(163) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y4))
IF3(false, y0, s(y1), s(y2), empty, y4) → REACH(s(y1), s(y2), empty, edge(from(empty), to(empty), y4))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(164) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(165) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(166) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y4)) at position [3,0] we obtained the following new rules [LPAR04]:

IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, to(edge(x0, x1, x2)), y4))

(167) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, to(edge(x0, x1, x2)), y4))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(168) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(169) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, to(edge(x0, x1, x2)), y4))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(170) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

from(edge(x0, x1, x2))

(171) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, to(edge(x0, x1, x2)), y4))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(172) Rewriting (EQUIVALENT transformation)

By rewriting [LPAR04] the rule IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, to(edge(x0, x1, x2)), y4)) at position [3,1] we obtained the following new rules [LPAR04]:

IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))

(173) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(174) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(175) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(176) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

to(edge(x0, x1, x2))

(177) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(178) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4) at position [2] we obtained the following new rules [LPAR04]:

IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF4(false, s(y0), s(y1), empty, y3) → REACH(s(y0), s(y1), empty, y3)

(179) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF4(false, s(y0), s(y1), empty, y3) → REACH(s(y0), s(y1), empty, y3)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(180) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(181) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(182) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(183) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.

(184) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

rest(edge(x0, x1, x2))
rest(empty)

(185) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(186) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty) at position [2] we obtained the following new rules [LPAR04]:

IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)

(187) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(188) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6) we obtained the following new rules [LPAR04]:

IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)

(189) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(190) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6) we obtained the following new rules [LPAR04]:

IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)

(191) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(192) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5) we obtained the following new rules [LPAR04]:

IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)

(193) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(194) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6) we obtained the following new rules [LPAR04]:

IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)

(195) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(196) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3)) we obtained the following new rules [LPAR04]:

IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

(197) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(198) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) we obtained the following new rules [LPAR04]:

IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF1(false, false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6)

(199) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF1(false, false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(200) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2) at position [2] we obtained the following new rules [LPAR04]:

REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)

(201) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF1(false, false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(202) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF1(false, false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) we obtained the following new rules [LPAR04]:

IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)

(203) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(204) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6) we obtained the following new rules [LPAR04]:

IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)

(205) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(206) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6) we obtained the following new rules [LPAR04]:

IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)

(207) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(208) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2) we obtained the following new rules [LPAR04]:

IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)

(209) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(210) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty) we obtained the following new rules [LPAR04]:

IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)

(211) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(212) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty) we obtained the following new rules [LPAR04]:

IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)

(213) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(214) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3) we obtained the following new rules [LPAR04]:

IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)

(215) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(216) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4)) we obtained the following new rules [LPAR04]:

IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))

(217) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(218) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty) we obtained the following new rules [LPAR04]:

IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x1), edge(0, y_1, y_2), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x1), edge(s(y_1), y_2, y_3), empty)

(219) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x1), edge(0, y_1, y_2), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x1), edge(s(y_1), y_2, y_3), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(220) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) we obtained the following new rules [LPAR04]:

IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)

(221) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x1), edge(0, y_1, y_2), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x1), edge(s(y_1), y_2, y_3), empty)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(222) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7) we obtained the following new rules [LPAR04]:

IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5))

(223) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x1), edge(0, y_1, y_2), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x1), edge(s(y_1), y_2, y_3), empty)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(224) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF4(z0, 0, s(z1), edge(0, z2, z3), z4) we obtained the following new rules [LPAR04]:

IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF3(true, false, 0, s(x1), edge(0, x2, empty), x4) → IF4(false, 0, s(x1), edge(0, x2, empty), x4)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)

(225) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x1), edge(0, y_1, y_2), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x1), edge(s(y_1), y_2, y_3), empty)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5))
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF3(true, false, 0, s(x1), edge(0, x2, empty), x4) → IF4(false, 0, s(x1), edge(0, x2, empty), x4)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(226) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF4(false, 0, s(z1), edge(0, z2, z3), z4) → REACH(0, s(z1), z3, z4) we obtained the following new rules [LPAR04]:

IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)

(227) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x1), edge(0, y_1, y_2), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x1), edge(s(y_1), y_2, y_3), empty)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5))
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF3(true, false, 0, s(x1), edge(0, x2, empty), x4) → IF4(false, 0, s(x1), edge(0, x2, empty), x4)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(228) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule IF4(false, 0, s(z1), edge(0, z2, empty), z4) → REACH(z2, s(z1), z4, empty) we obtained the following new rules [LPAR04]:

IF4(false, 0, s(x0), edge(0, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x0), edge(y_2, y_3, y_4), empty)
IF4(false, 0, s(x0), edge(0, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x0), edge(0, y_1, y_2), empty)
IF4(false, 0, s(x0), edge(0, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), empty)

(229) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x1), edge(0, y_1, y_2), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x1), edge(s(y_1), y_2, y_3), empty)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5))
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF3(true, false, 0, s(x1), edge(0, x2, empty), x4) → IF4(false, 0, s(x1), edge(0, x2, empty), x4)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)
IF4(false, 0, s(x0), edge(0, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x0), edge(y_2, y_3, y_4), empty)
IF4(false, 0, s(x0), edge(0, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x0), edge(0, y_1, y_2), empty)
IF4(false, 0, s(x0), edge(0, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(230) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x1), edge(0, y_1, y_2), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x1), edge(s(y_1), y_2, y_3), empty)
IF4(false, 0, s(x0), edge(0, 0, empty), edge(0, y_1, y_2)) → REACH(0, s(x0), edge(0, y_1, y_2), empty)
IF4(false, 0, s(x0), edge(0, 0, empty), edge(s(y_1), y_2, y_3)) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), empty)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 1   
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₇ + x₈   
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₆ + x₇   
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆   
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅   
POL(REACH(x₁, x₂, x₃, x₄)) = x₃ + x₄   
POL(edge(x₁, x₂, x₃)) = x₂ + x₃   
POL(empty) = 0   
POL(eq(x₁, x₂)) = 0   
POL(false) = 0   
POL(s(x₁)) = 0   
POL(true) = 0   
POL(union(x₁, x₂)) = x₁ + x₂   

The following usable rules [FROCOS05] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

(231) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(0, y_3, y_4))
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(s(y_3), y_4, y_5))
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF3(true, false, 0, s(x1), edge(0, x2, empty), x4) → IF4(false, 0, s(x1), edge(0, x2, empty), x4)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)
IF4(false, 0, s(x0), edge(0, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x0), edge(y_2, y_3, y_4), empty)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(232) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.

(233) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)
IF4(false, 0, s(x0), edge(0, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x0), edge(y_2, y_3, y_4), empty)
IF3(true, false, 0, s(x1), edge(0, x2, empty), x4) → IF4(false, 0, s(x1), edge(0, x2, empty), x4)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(234) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

IF4(false, 0, s(x0), edge(0, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x0), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₇ + x₈   
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₆ + x₇   
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆   
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅   
POL(REACH(x₁, x₂, x₃, x₄)) = x₃ + x₄   
POL(edge(x₁, x₂, x₃)) = x₂ + x₃   
POL(empty) = 0   
POL(eq(x₁, x₂)) = 0   
POL(false) = 0   
POL(s(x₁)) = 1   
POL(true) = 0   
POL(union(x₁, x₂)) = x₁ + x₂   

The following usable rules [FROCOS05] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

(235) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)
IF3(true, false, 0, s(x1), edge(0, x2, empty), x4) → IF4(false, 0, s(x1), edge(0, x2, empty), x4)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(236) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.

(237) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(238) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₅ + x₇ + x₈   
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₄ + x₆ + x₇   
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₃ + x₅ + x₆   
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₂ + x₄ + x₅   
POL(REACH(x₁, x₂, x₃, x₄)) = x₁ + x₃ + x₄   
POL(edge(x₁, x₂, x₃)) = x₂ + x₃   
POL(empty) = 0   
POL(eq(x₁, x₂)) = 0   
POL(false) = 0   
POL(s(x₁)) = 1   
POL(true) = 0   
POL(union(x₁, x₂)) = x₁ + x₂   

The following usable rules [FROCOS05] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

(239) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(240) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs.

(241) Complex Obligation (AND)

(242) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(243) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(244) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(245) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

union(empty, x0)
union(edge(x0, x1, x2), x3)

(246) Obligation:

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.

(247) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
  The graph contains the following edges 2 >= 1, 3 >= 2, 4 > 3, 5 >= 4

• IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
  The graph contains the following edges 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6

• REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
  The graph contains the following edges 1 >= 5, 2 >= 6, 3 >= 7, 4 >= 8

• IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
  The graph contains the following edges 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5

• IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
  The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6, 8 >= 7

• IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
  The graph contains the following edges 3 >= 1, 4 >= 2, 5 > 3

• IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, edge(y_5, y_6, y_7)), x7)
  The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6

(248) TRUE

(249) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(250) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

IF4(false, 0, s(z1), edge(0, z2, edge(x3, x4, x5)), z4) → REACH(z2, s(z1), edge(x3, x4, union(x5, z4)), empty)
IF4(false, 0, s(x0), edge(0, x1, edge(0, y_1, y_2)), x3) → REACH(0, s(x0), edge(0, y_1, y_2), x3)
IF4(false, 0, s(x0), edge(0, x1, edge(s(y_1), y_2, y_3)), x3) → REACH(0, s(x0), edge(s(y_1), y_2, y_3), x3)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 1   
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₇ + x₈   
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₆ + x₇   
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆   
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅   
POL(REACH(x₁, x₂, x₃, x₄)) = x₃ + x₄   
POL(edge(x₁, x₂, x₃)) = x₁ + x₃   
POL(empty) = 0   
POL(eq(x₁, x₂)) = 0   
POL(false) = 0   
POL(s(x₁)) = 0   
POL(true) = 0   
POL(union(x₁, x₂)) = x₁ + x₂   

The following usable rules [FROCOS05] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

(251) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(0, y2, y3), y4) → IF1(false, false, true, eq(s(y0), y2), 0, s(y0), edge(0, y2, y3), y4)
IF1(false, false, true, y_0, 0, s(z0), edge(0, z1, z2), z3) → IF2(false, true, y_0, 0, s(z0), edge(0, z1, z2), z3)
IF2(false, true, z0, 0, s(z1), edge(0, z2, z3), z4) → IF3(true, z0, 0, s(z1), edge(0, z2, z3), z4)
IF3(true, false, 0, s(x1), edge(0, x2, x3), x4) → IF4(false, 0, s(x1), edge(0, x2, x3), x4)
REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(true, false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4) → IF4(false, 0, s(x1), edge(0, x2, edge(y_2, y_3, y_4)), x4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(252) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 5 less nodes.

(253) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(254) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(255) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.

(256) QReductionProof (EQUIVALENT transformation)

We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

union(empty, x0)
union(edge(x0, x1, x2), x3)

(257) Obligation:

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.

(258) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• IF1(false, false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6)
  The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 1, 1 >= 2, 2 >= 2, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6, 8 >= 7

• IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
  The graph contains the following edges 3 >= 1, 4 >= 2, 5 > 3

• IF2(false, false, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, x5), x6)
  The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6

• REACH(0, s(y0), edge(s(x0), y2, y3), y4) → IF1(false, false, false, eq(s(y0), y2), 0, s(y0), edge(s(x0), y2, y3), y4)
  The graph contains the following edges 1 >= 5, 2 >= 6, 3 >= 7, 4 >= 8

(259) TRUE