(0) Obligation:

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

f(x, y) → cond(and(isNat(x), isNat(y)), x, y)
cond(tt, x, y) → f(s(x), s(y))
isNat(s(x)) → isNat(x)
isNat(0) → tt
and(tt, tt) → tt
and(ff, x) → ff
and(x, ff) → ff

Q is empty.

(1) DependencyPairsProof (EQUIVALENT transformation)

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

(2) Obligation:

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

F(x, y) → COND(and(isNat(x), isNat(y)), x, y)
F(x, y) → AND(isNat(x), isNat(y))
F(x, y) → ISNAT(x)
F(x, y) → ISNAT(y)
COND(tt, x, y) → F(s(x), s(y))
ISNAT(s(x)) → ISNAT(x)

The TRS R consists of the following rules:

f(x, y) → cond(and(isNat(x), isNat(y)), x, y)
cond(tt, x, y) → f(s(x), s(y))
isNat(s(x)) → isNat(x)
isNat(0) → tt
and(tt, tt) → tt
and(ff, x) → ff
and(x, ff) → ff

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

(3) DependencyGraphProof (EQUIVALENT transformation)

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

(4) Complex Obligation (AND)

(5) Obligation:

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

ISNAT(s(x)) → ISNAT(x)

The TRS R consists of the following rules:

f(x, y) → cond(and(isNat(x), isNat(y)), x, y)
cond(tt, x, y) → f(s(x), s(y))
isNat(s(x)) → isNat(x)
isNat(0) → tt
and(tt, tt) → tt
and(ff, x) → ff
and(x, ff) → ff

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

(6) 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:

  • ISNAT(s(x)) → ISNAT(x)
    The graph contains the following edges 1 > 1

(7) YES

(8) Obligation:

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

COND(tt, x, y) → F(s(x), s(y))
F(x, y) → COND(and(isNat(x), isNat(y)), x, y)

The TRS R consists of the following rules:

f(x, y) → cond(and(isNat(x), isNat(y)), x, y)
cond(tt, x, y) → f(s(x), s(y))
isNat(s(x)) → isNat(x)
isNat(0) → tt
and(tt, tt) → tt
and(ff, x) → ff
and(x, ff) → ff

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

(9) NonLoopProof (EQUIVALENT transformation)

By Theorem 8 [NONLOOP] we deduce infiniteness of the QDP.
We apply the theorem with m = 1, b = 1,
σ' = [ ], and μ' = [ ] on the rule
COND(tt, zr2, zr0)[zr2 / s(zr2), zr0 / s(zr0)]n[zr2 / 0, zr0 / 0] → COND(tt, s(zr2), s(zr0))[zr0 / s(zr0), zr2 / s(zr2)]n[zr0 / 0, zr2 / 0]
This rule is correct for the QDP as the following derivation shows:

intermediate steps: Equivalent (Domain Renaming) - Equivalent (Domain Renaming) - Equivalent (Remove Unused)
COND(tt, zl1, zl3)[zl1 / s(zl1), zl3 / s(zl3), zr1 / s(zr1), zr3 / s(zr3)]n[zl1 / 0, zl3 / 0, zr1 / 0, zr3 / 0] → COND(tt, s(zr3), s(zr1))[zl1 / s(zl1), zl3 / s(zl3), zr1 / s(zr1), zr3 / s(zr3)]n[zl1 / 0, zl3 / 0, zr1 / 0, zr3 / 0]
    by Narrowing at position: [0]
        intermediate steps: Equivalent (Add Unused) - Equivalent (Add Unused) - Equivalent (Domain Renaming) - Equivalent (Domain Renaming) - Equivalent (Remove Unused)
        COND(tt, zl1, zl3)[zl1 / s(zl1), zl3 / s(zl3), zr1 / s(zr1), zr3 / s(zr3)]n[zl1 / 0, zl3 / 0, zr1 / 0, zr3 / 0] → COND(and(tt, tt), s(zr3), s(zr1))[zl1 / s(zl1), zl3 / s(zl3), zr1 / s(zr1), zr3 / s(zr3)]n[zl1 / 0, zl3 / 0, zr1 / 0, zr3 / 0]
            by Narrowing at position: [0,1]
                intermediate steps: Equivalent (Add Unused) - Equivalent (Add Unused) - Instantiation - Equivalent (Domain Renaming) - Equivalent (Domain Renaming) - Equivalent (Remove Unused)
                COND(tt, zl1, zl3)[zl1 / s(zl1), zl3 / s(zl3), zr1 / s(zr1), zr3 / s(zr3)]n[zl1 / 0, zl3 / x0, zr1 / x0, zr3 / 0] → COND(and(tt, isNat(x0)), s(zr3), s(zr1))[zl1 / s(zl1), zl3 / s(zl3), zr1 / s(zr1), zr3 / s(zr3)]n[zl1 / 0, zl3 / x0, zr1 / x0, zr3 / 0]
                    by Narrowing at position: [0,0]
                        intermediate steps: Equivalent (Add Unused) - Equivalent (Add Unused) - Instantiation - Equivalent (Domain Renaming) - Instantiation - Equivalent (Domain Renaming) - Equivalent (Remove Unused)
                        COND(tt, zl1, x1)[zl1 / s(zl1), x1 / s(x1), zr1 / s(zr1)]n[zl1 / x0, x1 / y0, zr1 / x0] → COND(and(isNat(x0), isNat(y0)), s(zr1), s(x1))[zl1 / s(zl1), x1 / s(x1), zr1 / s(zr1)]n[zl1 / x0, x1 / y0, zr1 / x0]
                            by Narrowing at position: [0,1]
                                intermediate steps: Equivalent (Add Unused) - Instantiate mu - Equivalent (Add Unused) - Instantiate Sigma - Equivalent (Domain Renaming) - Instantiation - Equivalent (Domain Renaming)
                                COND(tt, x1, x0)[x1 / s(x1)]n[x1 / y0] → COND(and(isNat(y0), isNat(s(x0))), s(x1), s(x0))[x1 / s(x1)]n[x1 / y0]
                                    by Narrowing at position: [0,0]
                                        intermediate steps: Instantiate mu - Instantiate Sigma
                                        COND(tt, x1, x0)[ ]n[ ] → COND(and(isNat(s(x1)), isNat(s(x0))), s(x1), s(x0))[ ]n[ ]
                                            by Narrowing at position: []
                                                intermediate steps: Instantiation
                                                COND(tt, x, y)[ ]n[ ] → F(s(x), s(y))[ ]n[ ]
                                                    by OriginalRule from TRS P

                                                intermediate steps: Instantiation - Instantiation - Instantiation
                                                F(x, y)[ ]n[ ] → COND(and(isNat(x), isNat(y)), x, y)[ ]n[ ]
                                                    by OriginalRule from TRS P

                                        intermediate steps: Equivalent (Add Unused) - Equivalent (Add Unused) - Equivalent (Domain Renaming) - Equivalent (Domain Renaming) - Instantiation - Equivalent (Domain Renaming)
                                        isNat(s(x))[x / s(x)]n[ ] → isNat(x)[ ]n[ ]
                                            by PatternCreation I
                                                isNat(s(x))[ ]n[ ] → isNat(x)[ ]n[ ]
                                                    by OriginalRule from TRS R

                                intermediate steps: Equivalent (Add Unused) - Equivalent (Add Unused) - Equivalent (Domain Renaming) - Equivalent (Domain Renaming) - Instantiation - Equivalent (Domain Renaming)
                                isNat(s(x))[x / s(x)]n[ ] → isNat(x)[ ]n[ ]
                                    by PatternCreation I
                                        isNat(s(x))[ ]n[ ] → isNat(x)[ ]n[ ]
                                            by OriginalRule from TRS R

                        intermediate steps: Equivalent (Add Unused) - Equivalent (Add Unused)
                        isNat(0)[ ]n[ ] → tt[ ]n[ ]
                            by OriginalRule from TRS R

                intermediate steps: Equivalent (Add Unused) - Equivalent (Add Unused)
                isNat(0)[ ]n[ ] → tt[ ]n[ ]
                    by OriginalRule from TRS R

        intermediate steps: Equivalent (Add Unused) - Equivalent (Add Unused)
        and(tt, tt)[ ]n[ ] → tt[ ]n[ ]
            by OriginalRule from TRS R

(10) NO