Termination w.r.t. Q proof of /tmp/tmpJwbjR4/PEANO_complete-noand

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

0 QTRS

↳1 DependencyPairsProof (⇔)

↳2 QDP

↳3 DependencyGraphProof (⇔)

↳4 QDP

↳5 QDPOrderProof (⇔)

↳6 QDP

↳7 DependencyGraphProof (⇔)

↳8 AND

    ↳9 QDP

        ↳10 QDPOrderProof (⇔)

        ↳11 QDP

        ↳12 PisEmptyProof (⇔)

        ↳13 TRUE

    ↳14 QDP

        ↳15 QDPOrderProof (⇔)

        ↳16 QDP

        ↳17 PisEmptyProof (⇔)

        ↳18 TRUE

    ↳19 QDP

        ↳20 QDPOrderProof (⇔)

        ↳21 QDP

        ↳22 PisEmptyProof (⇔)

        ↳23 TRUE

(0) Obligation:

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

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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:

U11¹(tt, V1, V2) → U12¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U11¹(tt, V1, V2) → ISNATKIND(activate(V1))
U11¹(tt, V1, V2) → ACTIVATE(V1)
U11¹(tt, V1, V2) → ACTIVATE(V2)
U12¹(tt, V1, V2) → U13¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U12¹(tt, V1, V2) → ISNATKIND(activate(V2))
U12¹(tt, V1, V2) → ACTIVATE(V2)
U12¹(tt, V1, V2) → ACTIVATE(V1)
U13¹(tt, V1, V2) → U14¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U13¹(tt, V1, V2) → ISNATKIND(activate(V2))
U13¹(tt, V1, V2) → ACTIVATE(V2)
U13¹(tt, V1, V2) → ACTIVATE(V1)
U14¹(tt, V1, V2) → U15¹(isNat(activate(V1)), activate(V2))
U14¹(tt, V1, V2) → ISNAT(activate(V1))
U14¹(tt, V1, V2) → ACTIVATE(V1)
U14¹(tt, V1, V2) → ACTIVATE(V2)
U15¹(tt, V2) → U16¹(isNat(activate(V2)))
U15¹(tt, V2) → ISNAT(activate(V2))
U15¹(tt, V2) → ACTIVATE(V2)
U21¹(tt, V1) → U22¹(isNatKind(activate(V1)), activate(V1))
U21¹(tt, V1) → ISNATKIND(activate(V1))
U21¹(tt, V1) → ACTIVATE(V1)
U22¹(tt, V1) → U23¹(isNat(activate(V1)))
U22¹(tt, V1) → ISNAT(activate(V1))
U22¹(tt, V1) → ACTIVATE(V1)
U31¹(tt, V2) → U32¹(isNatKind(activate(V2)))
U31¹(tt, V2) → ISNATKIND(activate(V2))
U31¹(tt, V2) → ACTIVATE(V2)
U51¹(tt, N) → U52¹(isNatKind(activate(N)), activate(N))
U51¹(tt, N) → ISNATKIND(activate(N))
U51¹(tt, N) → ACTIVATE(N)
U52¹(tt, N) → ACTIVATE(N)
U61¹(tt, M, N) → U62¹(isNatKind(activate(M)), activate(M), activate(N))
U61¹(tt, M, N) → ISNATKIND(activate(M))
U61¹(tt, M, N) → ACTIVATE(M)
U61¹(tt, M, N) → ACTIVATE(N)
U62¹(tt, M, N) → U63¹(isNat(activate(N)), activate(M), activate(N))
U62¹(tt, M, N) → ISNAT(activate(N))
U62¹(tt, M, N) → ACTIVATE(N)
U62¹(tt, M, N) → ACTIVATE(M)
U63¹(tt, M, N) → U64¹(isNatKind(activate(N)), activate(M), activate(N))
U63¹(tt, M, N) → ISNATKIND(activate(N))
U63¹(tt, M, N) → ACTIVATE(N)
U63¹(tt, M, N) → ACTIVATE(M)
U64¹(tt, M, N) → S(plus(activate(N), activate(M)))
U64¹(tt, M, N) → PLUS(activate(N), activate(M))
U64¹(tt, M, N) → ACTIVATE(N)
U64¹(tt, M, N) → ACTIVATE(M)
ISNAT(n__plus(V1, V2)) → U11¹(isNatKind(activate(V1)), activate(V1), activate(V2))
ISNAT(n__plus(V1, V2)) → ISNATKIND(activate(V1))
ISNAT(n__plus(V1, V2)) → ACTIVATE(V1)
ISNAT(n__plus(V1, V2)) → ACTIVATE(V2)
ISNAT(n__s(V1)) → U21¹(isNatKind(activate(V1)), activate(V1))
ISNAT(n__s(V1)) → ISNATKIND(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
ISNATKIND(n__plus(V1, V2)) → U31¹(isNatKind(activate(V1)), activate(V2))
ISNATKIND(n__plus(V1, V2)) → ISNATKIND(activate(V1))
ISNATKIND(n__plus(V1, V2)) → ACTIVATE(V1)
ISNATKIND(n__plus(V1, V2)) → ACTIVATE(V2)
ISNATKIND(n__s(V1)) → U41¹(isNatKind(activate(V1)))
ISNATKIND(n__s(V1)) → ISNATKIND(activate(V1))
ISNATKIND(n__s(V1)) → ACTIVATE(V1)
PLUS(N, 0) → U51¹(isNat(N), N)
PLUS(N, 0) → ISNAT(N)
PLUS(N, s(M)) → U61¹(isNat(M), M, N)
PLUS(N, s(M)) → ISNAT(M)
ACTIVATE(n__0) → 0¹
ACTIVATE(n__plus(X1, X2)) → PLUS(activate(X1), activate(X2))
ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__s(X)) → S(activate(X))
ACTIVATE(n__s(X)) → ACTIVATE(X)

The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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 1 SCC with 7 less nodes.

(4) Obligation:

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

U12¹(tt, V1, V2) → U13¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U13¹(tt, V1, V2) → U14¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U14¹(tt, V1, V2) → U15¹(isNat(activate(V1)), activate(V2))
U15¹(tt, V2) → ISNAT(activate(V2))
ISNAT(n__plus(V1, V2)) → U11¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U11¹(tt, V1, V2) → U12¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U12¹(tt, V1, V2) → ISNATKIND(activate(V2))
ISNATKIND(n__plus(V1, V2)) → U31¹(isNatKind(activate(V1)), activate(V2))
U31¹(tt, V2) → ISNATKIND(activate(V2))
ISNATKIND(n__plus(V1, V2)) → ISNATKIND(activate(V1))
ISNATKIND(n__plus(V1, V2)) → ACTIVATE(V1)
ACTIVATE(n__plus(X1, X2)) → PLUS(activate(X1), activate(X2))
PLUS(N, 0) → U51¹(isNat(N), N)
U51¹(tt, N) → U52¹(isNatKind(activate(N)), activate(N))
U52¹(tt, N) → ACTIVATE(N)
ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__s(X)) → ACTIVATE(X)
U51¹(tt, N) → ISNATKIND(activate(N))
ISNATKIND(n__plus(V1, V2)) → ACTIVATE(V2)
ISNATKIND(n__s(V1)) → ISNATKIND(activate(V1))
ISNATKIND(n__s(V1)) → ACTIVATE(V1)
U51¹(tt, N) → ACTIVATE(N)
PLUS(N, 0) → ISNAT(N)
ISNAT(n__plus(V1, V2)) → ISNATKIND(activate(V1))
ISNAT(n__plus(V1, V2)) → ACTIVATE(V1)
ISNAT(n__plus(V1, V2)) → ACTIVATE(V2)
ISNAT(n__s(V1)) → U21¹(isNatKind(activate(V1)), activate(V1))
U21¹(tt, V1) → U22¹(isNatKind(activate(V1)), activate(V1))
U22¹(tt, V1) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ISNATKIND(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
U22¹(tt, V1) → ACTIVATE(V1)
U21¹(tt, V1) → ISNATKIND(activate(V1))
U21¹(tt, V1) → ACTIVATE(V1)
PLUS(N, s(M)) → U61¹(isNat(M), M, N)
U61¹(tt, M, N) → U62¹(isNatKind(activate(M)), activate(M), activate(N))
U62¹(tt, M, N) → U63¹(isNat(activate(N)), activate(M), activate(N))
U63¹(tt, M, N) → U64¹(isNatKind(activate(N)), activate(M), activate(N))
U64¹(tt, M, N) → PLUS(activate(N), activate(M))
PLUS(N, s(M)) → ISNAT(M)
U64¹(tt, M, N) → ACTIVATE(N)
U64¹(tt, M, N) → ACTIVATE(M)
U63¹(tt, M, N) → ISNATKIND(activate(N))
U63¹(tt, M, N) → ACTIVATE(N)
U63¹(tt, M, N) → ACTIVATE(M)
U62¹(tt, M, N) → ISNAT(activate(N))
U62¹(tt, M, N) → ACTIVATE(N)
U62¹(tt, M, N) → ACTIVATE(M)
U61¹(tt, M, N) → ISNATKIND(activate(M))
U61¹(tt, M, N) → ACTIVATE(M)
U61¹(tt, M, N) → ACTIVATE(N)
U31¹(tt, V2) → ACTIVATE(V2)
U12¹(tt, V1, V2) → ACTIVATE(V2)
U12¹(tt, V1, V2) → ACTIVATE(V1)
U11¹(tt, V1, V2) → ISNATKIND(activate(V1))
U11¹(tt, V1, V2) → ACTIVATE(V1)
U11¹(tt, V1, V2) → ACTIVATE(V2)
U15¹(tt, V2) → ACTIVATE(V2)
U14¹(tt, V1, V2) → ISNAT(activate(V1))
U14¹(tt, V1, V2) → ACTIVATE(V1)
U14¹(tt, V1, V2) → ACTIVATE(V2)
U13¹(tt, V1, V2) → ISNATKIND(activate(V2))
U13¹(tt, V1, V2) → ACTIVATE(V2)
U13¹(tt, V1, V2) → ACTIVATE(V1)

The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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

(5) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ISNATKIND(n__plus(V1, V2)) → ACTIVATE(V1)
PLUS(N, 0) → U51¹(isNat(N), N)
U51¹(tt, N) → U52¹(isNatKind(activate(N)), activate(N))
ACTIVATE(n__s(X)) → ACTIVATE(X)
ISNATKIND(n__plus(V1, V2)) → ACTIVATE(V2)
ISNATKIND(n__s(V1)) → ISNATKIND(activate(V1))
ISNATKIND(n__s(V1)) → ACTIVATE(V1)
U51¹(tt, N) → ACTIVATE(N)
PLUS(N, 0) → ISNAT(N)
ISNAT(n__plus(V1, V2)) → ACTIVATE(V1)
ISNAT(n__plus(V1, V2)) → ACTIVATE(V2)
ISNAT(n__s(V1)) → U21¹(isNatKind(activate(V1)), activate(V1))
U21¹(tt, V1) → U22¹(isNatKind(activate(V1)), activate(V1))
U22¹(tt, V1) → ISNAT(activate(V1))
ISNAT(n__s(V1)) → ISNATKIND(activate(V1))
ISNAT(n__s(V1)) → ACTIVATE(V1)
U22¹(tt, V1) → ACTIVATE(V1)
U21¹(tt, V1) → ISNATKIND(activate(V1))
U21¹(tt, V1) → ACTIVATE(V1)
U62¹(tt, M, N) → U63¹(isNat(activate(N)), activate(M), activate(N))
U63¹(tt, M, N) → U64¹(isNatKind(activate(N)), activate(M), activate(N))
U64¹(tt, M, N) → PLUS(activate(N), activate(M))
PLUS(N, s(M)) → ISNAT(M)
U64¹(tt, M, N) → ACTIVATE(N)
U64¹(tt, M, N) → ACTIVATE(M)
U63¹(tt, M, N) → ISNATKIND(activate(N))
U63¹(tt, M, N) → ACTIVATE(N)
U63¹(tt, M, N) → ACTIVATE(M)
U62¹(tt, M, N) → ISNAT(activate(N))
U62¹(tt, M, N) → ACTIVATE(N)
U62¹(tt, M, N) → ACTIVATE(M)
U61¹(tt, M, N) → ISNATKIND(activate(M))
U61¹(tt, M, N) → ACTIVATE(M)
U61¹(tt, M, N) → ACTIVATE(N)
U31¹(tt, V2) → ACTIVATE(V2)
U12¹(tt, V1, V2) → ACTIVATE(V2)
U12¹(tt, V1, V2) → ACTIVATE(V1)
U11¹(tt, V1, V2) → ACTIVATE(V1)
U11¹(tt, V1, V2) → ACTIVATE(V2)
U15¹(tt, V2) → ACTIVATE(V2)
U14¹(tt, V1, V2) → ACTIVATE(V1)
U14¹(tt, V1, V2) → ACTIVATE(V2)
U13¹(tt, V1, V2) → ACTIVATE(V2)
U13¹(tt, V1, V2) → ACTIVATE(V1)

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
U12¹(x0, x1, x2, x3) = U12¹(x0)
U13¹(x0, x1, x2, x3) = U13¹(x0)
U14¹(x0, x1, x2, x3) = U14¹(x0)
U15¹(x0, x1, x2) = U15¹(x2)
ISNAT(x0, x1) = ISNAT(x0)
U11¹(x0, x1, x2, x3) = U11¹(x0)
ISNATKIND(x0, x1) = ISNATKIND(x1)
U31¹(x0, x1, x2) = U31¹(x0)
ACTIVATE(x0, x1) = ACTIVATE(x0, x1)
PLUS(x0, x1, x2) = PLUS(x0)
U51¹(x0, x1, x2) = U51¹(x2)
U52¹(x0, x1, x2) = U52¹(x2)
U21¹(x0, x1, x2) = U21¹(x0, x2)
U22¹(x0, x1, x2) = U22¹(x0)
U61¹(x0, x1, x2, x3) = U61¹(x0)
U62¹(x0, x1, x2, x3) = U62¹(x0)
U63¹(x0, x1, x2, x3) = U63¹(x0)
U64¹(x0, x1, x2, x3) = U64¹(x0)

Tags:
U12¹ has argument tags [0,60,56,32] and root tag 18
U13¹ has argument tags [0,1,34,32] and root tag 18
U14¹ has argument tags [0,34,0,0] and root tag 18
U15¹ has argument tags [0,56,0] and root tag 18
ISNAT has argument tags [0,32] and root tag 18
U11¹ has argument tags [0,0,0,0] and root tag 18
ISNATKIND has argument tags [32,0] and root tag 18
U31¹ has argument tags [0,48,0] and root tag 18
ACTIVATE has argument tags [33,0] and root tag 16
PLUS has argument tags [0,0,62] and root tag 16
U51¹ has argument tags [32,43,0] and root tag 18
U52¹ has argument tags [0,34,0] and root tag 16
U21¹ has argument tags [8,0,8] and root tag 2
U22¹ has argument tags [0,32,10] and root tag 24
U61¹ has argument tags [0,15,0,32] and root tag 16
U62¹ has argument tags [0,31,34,0] and root tag 16
U63¹ has argument tags [0,21,0,0] and root tag 14
U64¹ has argument tags [4,62,32,0] and root tag 16

Comparison: MIN
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(0) = 1
POL(ACTIVATE(x₁)) = 1 + x₁
POL(ISNAT(x₁)) = x₁
POL(ISNATKIND(x₁)) = 1
POL(PLUS(x₁, x₂)) = x₁ + x₂
POL(U11(x₁, x₂, x₃)) = 1 + x₁ + x₂
POL(U11¹(x₁, x₂, x₃)) = x₂ + x₃
POL(U12(x₁, x₂, x₃)) = x₃
POL(U12¹(x₁, x₂, x₃)) = x₂ + x₃
POL(U13(x₁, x₂, x₃)) = 0
POL(U13¹(x₁, x₂, x₃)) = x₂ + x₃
POL(U14(x₁, x₂, x₃)) = x₂
POL(U14¹(x₁, x₂, x₃)) = x₂ + x₃
POL(U15(x₁, x₂)) = 1 + x₂
POL(U15¹(x₁, x₂)) = 1
POL(U16(x₁)) = 1
POL(U21(x₁, x₂)) = 1 + x₁ + x₂
POL(U21¹(x₁, x₂)) = x₂
POL(U22(x₁, x₂)) = 0
POL(U22¹(x₁, x₂)) = x₂
POL(U23(x₁)) = 0
POL(U31(x₁, x₂)) = 0
POL(U31¹(x₁, x₂)) = x₂
POL(U32(x₁)) = 0
POL(U41(x₁)) = 0
POL(U51(x₁, x₂)) = x₂
POL(U51¹(x₁, x₂)) = 1
POL(U52(x₁, x₂)) = x₂
POL(U52¹(x₁, x₂)) = 1 + x₁
POL(U61(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U61¹(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U62(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U62¹(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U63(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U63¹(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U64(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U64¹(x₁, x₂, x₃)) = x₂ + x₃
POL(activate(x₁)) = x₁
POL(isNat(x₁)) = 0
POL(isNatKind(x₁)) = 1 + x₁
POL(n__0) = 1
POL(n__plus(x₁, x₂)) = x₁ + x₂
POL(n__s(x₁)) = 1 + x₁
POL(plus(x₁, x₂)) = x₁ + x₂
POL(s(x₁)) = 1 + x₁
POL(tt) = 0

The following usable rules [FROCOS05] were oriented:

activate(n__0) → 0
U52(tt, N) → activate(N)
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
plus(N, 0) → U51(isNat(N), N)
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
activate(n__s(X)) → s(activate(X))
activate(X) → X
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, s(M)) → U61(isNat(M), M, N)
U31(tt, V2) → U32(isNatKind(activate(V2)))
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
s(X) → n__s(X)
plus(X1, X2) → n__plus(X1, X2)
U41(tt) → tt
U32(tt) → tt
0 → n__0

(6) Obligation:

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

U12¹(tt, V1, V2) → U13¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U13¹(tt, V1, V2) → U14¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U14¹(tt, V1, V2) → U15¹(isNat(activate(V1)), activate(V2))
U15¹(tt, V2) → ISNAT(activate(V2))
ISNAT(n__plus(V1, V2)) → U11¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U11¹(tt, V1, V2) → U12¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U12¹(tt, V1, V2) → ISNATKIND(activate(V2))
ISNATKIND(n__plus(V1, V2)) → U31¹(isNatKind(activate(V1)), activate(V2))
U31¹(tt, V2) → ISNATKIND(activate(V2))
ISNATKIND(n__plus(V1, V2)) → ISNATKIND(activate(V1))
ACTIVATE(n__plus(X1, X2)) → PLUS(activate(X1), activate(X2))
U52¹(tt, N) → ACTIVATE(N)
ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X1)
ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X2)
U51¹(tt, N) → ISNATKIND(activate(N))
ISNAT(n__plus(V1, V2)) → ISNATKIND(activate(V1))
PLUS(N, s(M)) → U61¹(isNat(M), M, N)
U61¹(tt, M, N) → U62¹(isNatKind(activate(M)), activate(M), activate(N))
U11¹(tt, V1, V2) → ISNATKIND(activate(V1))
U14¹(tt, V1, V2) → ISNAT(activate(V1))
U13¹(tt, V1, V2) → ISNATKIND(activate(V2))

The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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

(7) DependencyGraphProof (EQUIVALENT transformation)

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

(8) Complex Obligation (AND)

(9) Obligation:

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

ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X1)

The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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

(10) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X2)
ACTIVATE(n__plus(X1, X2)) → ACTIVATE(X1)

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
ACTIVATE(x0, x1) = ACTIVATE(x1)

Tags:
ACTIVATE has argument tags [1,0] and root tag 0

Comparison: MAX
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(ACTIVATE(x₁)) = 1
POL(n__plus(x₁, x₂)) = 1 + x₁ + x₂

The following usable rules [FROCOS05] were oriented: none

(11) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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

(12) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(13) TRUE

(14) Obligation:

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

U31¹(tt, V2) → ISNATKIND(activate(V2))
ISNATKIND(n__plus(V1, V2)) → U31¹(isNatKind(activate(V1)), activate(V2))
ISNATKIND(n__plus(V1, V2)) → ISNATKIND(activate(V1))

The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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

(15) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U31¹(tt, V2) → ISNATKIND(activate(V2))
ISNATKIND(n__plus(V1, V2)) → U31¹(isNatKind(activate(V1)), activate(V2))
ISNATKIND(n__plus(V1, V2)) → ISNATKIND(activate(V1))

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
U31¹(x0, x1, x2) = U31¹(x0, x1, x2)
ISNATKIND(x0, x1) = ISNATKIND(x0, x1)

Tags:
U31¹ has argument tags [0,6,6] and root tag 1
ISNATKIND has argument tags [6,0] and root tag 0

Comparison: DMS
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(0) = 0
POL(ISNATKIND(x₁)) = 0
POL(U11(x₁, x₂, x₃)) = x₂
POL(U12(x₁, x₂, x₃)) = x₃
POL(U13(x₁, x₂, x₃)) = x₂
POL(U14(x₁, x₂, x₃)) = 0
POL(U15(x₁, x₂)) = 0
POL(U16(x₁)) = 0
POL(U21(x₁, x₂)) = 0
POL(U22(x₁, x₂)) = x₂
POL(U23(x₁)) = 1 + x₁
POL(U31(x₁, x₂)) = 0
POL(U31¹(x₁, x₂)) = 1 + x₂
POL(U32(x₁)) = 0
POL(U41(x₁)) = 0
POL(U51(x₁, x₂)) = x₂
POL(U52(x₁, x₂)) = x₂
POL(U61(x₁, x₂, x₃)) = 1 + x₃
POL(U62(x₁, x₂, x₃)) = 1 + x₃
POL(U63(x₁, x₂, x₃)) = 0
POL(U64(x₁, x₂, x₃)) = 0
POL(activate(x₁)) = x₁
POL(isNat(x₁)) = 1
POL(isNatKind(x₁)) = 0
POL(n__0) = 0
POL(n__plus(x₁, x₂)) = 1 + x₁ + x₂
POL(n__s(x₁)) = 0
POL(plus(x₁, x₂)) = 1 + x₁ + x₂
POL(s(x₁)) = 0
POL(tt) = 0

The following usable rules [FROCOS05] were oriented:

activate(n__0) → 0
U52(tt, N) → activate(N)
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
plus(N, 0) → U51(isNat(N), N)
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
activate(n__s(X)) → s(activate(X))
activate(X) → X
plus(N, s(M)) → U61(isNat(M), M, N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
s(X) → n__s(X)
plus(X1, X2) → n__plus(X1, X2)
0 → n__0

(16) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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

(17) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(18) TRUE

(19) Obligation:

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

U13¹(tt, V1, V2) → U14¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U14¹(tt, V1, V2) → U15¹(isNat(activate(V1)), activate(V2))
U15¹(tt, V2) → ISNAT(activate(V2))
ISNAT(n__plus(V1, V2)) → U11¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U11¹(tt, V1, V2) → U12¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U12¹(tt, V1, V2) → U13¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U14¹(tt, V1, V2) → ISNAT(activate(V1))

The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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

(20) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U13¹(tt, V1, V2) → U14¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U14¹(tt, V1, V2) → U15¹(isNat(activate(V1)), activate(V2))
U15¹(tt, V2) → ISNAT(activate(V2))
ISNAT(n__plus(V1, V2)) → U11¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U11¹(tt, V1, V2) → U12¹(isNatKind(activate(V1)), activate(V1), activate(V2))
U12¹(tt, V1, V2) → U13¹(isNatKind(activate(V2)), activate(V1), activate(V2))
U14¹(tt, V1, V2) → ISNAT(activate(V1))

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
U13¹(x0, x1, x2, x3) = U13¹(x0, x1)
U14¹(x0, x1, x2, x3) = U14¹(x0, x1)
U15¹(x0, x1, x2) = U15¹(x0)
ISNAT(x0, x1) = ISNAT(x0)
U11¹(x0, x1, x2, x3) = U11¹(x0)
U12¹(x0, x1, x2, x3) = U12¹(x0, x3)

Tags:
U13¹ has argument tags [24,11,8,22] and root tag 0
U14¹ has argument tags [24,9,0,4] and root tag 1
U15¹ has argument tags [24,28,0] and root tag 6
ISNAT has argument tags [3,2] and root tag 4
U11¹ has argument tags [26,2,13,13] and root tag 3
U12¹ has argument tags [24,3,16,19] and root tag 4

Comparison: MS
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(0) = 0
POL(ISNAT(x₁)) = 1 + x₁
POL(U11(x₁, x₂, x₃)) = 0
POL(U11¹(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U12(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U12¹(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U13(x₁, x₂, x₃)) = 0
POL(U13¹(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U14(x₁, x₂, x₃)) = 1
POL(U14¹(x₁, x₂, x₃)) = 1 + x₂ + x₃
POL(U15(x₁, x₂)) = x₂
POL(U15¹(x₁, x₂)) = 1 + x₂
POL(U16(x₁)) = 1
POL(U21(x₁, x₂)) = 1
POL(U22(x₁, x₂)) = x₂
POL(U23(x₁)) = 1
POL(U31(x₁, x₂)) = 0
POL(U32(x₁)) = 0
POL(U41(x₁)) = 0
POL(U51(x₁, x₂)) = x₂
POL(U52(x₁, x₂)) = x₂
POL(U61(x₁, x₂, x₃)) = 1 + x₃
POL(U62(x₁, x₂, x₃)) = 1 + x₃
POL(U63(x₁, x₂, x₃)) = 1 + x₃
POL(U64(x₁, x₂, x₃)) = 1 + x₃
POL(activate(x₁)) = x₁
POL(isNat(x₁)) = 0
POL(isNatKind(x₁)) = 0
POL(n__0) = 0
POL(n__plus(x₁, x₂)) = 1 + x₁ + x₂
POL(n__s(x₁)) = 1
POL(plus(x₁, x₂)) = 1 + x₁ + x₂
POL(s(x₁)) = 1
POL(tt) = 0

The following usable rules [FROCOS05] were oriented:

activate(n__0) → 0
U52(tt, N) → activate(N)
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
plus(N, 0) → U51(isNat(N), N)
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
activate(n__s(X)) → s(activate(X))
activate(X) → X
plus(N, s(M)) → U61(isNat(M), M, N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
s(X) → n__s(X)
plus(X1, X2) → n__plus(X1, X2)
0 → n__0

(21) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

U11(tt, V1, V2) → U12(isNatKind(activate(V1)), activate(V1), activate(V2))
U12(tt, V1, V2) → U13(isNatKind(activate(V2)), activate(V1), activate(V2))
U13(tt, V1, V2) → U14(isNatKind(activate(V2)), activate(V1), activate(V2))
U14(tt, V1, V2) → U15(isNat(activate(V1)), activate(V2))
U15(tt, V2) → U16(isNat(activate(V2)))
U16(tt) → tt
U21(tt, V1) → U22(isNatKind(activate(V1)), activate(V1))
U22(tt, V1) → U23(isNat(activate(V1)))
U23(tt) → tt
U31(tt, V2) → U32(isNatKind(activate(V2)))
U32(tt) → tt
U41(tt) → tt
U51(tt, N) → U52(isNatKind(activate(N)), activate(N))
U52(tt, N) → activate(N)
U61(tt, M, N) → U62(isNatKind(activate(M)), activate(M), activate(N))
U62(tt, M, N) → U63(isNat(activate(N)), activate(M), activate(N))
U63(tt, M, N) → U64(isNatKind(activate(N)), activate(M), activate(N))
U64(tt, M, N) → s(plus(activate(N), activate(M)))
isNat(n__0) → tt
isNat(n__plus(V1, V2)) → U11(isNatKind(activate(V1)), activate(V1), activate(V2))
isNat(n__s(V1)) → U21(isNatKind(activate(V1)), activate(V1))
isNatKind(n__0) → tt
isNatKind(n__plus(V1, V2)) → U31(isNatKind(activate(V1)), activate(V2))
isNatKind(n__s(V1)) → U41(isNatKind(activate(V1)))
plus(N, 0) → U51(isNat(N), N)
plus(N, s(M)) → U61(isNat(M), M, N)
0 → n__0
plus(X1, X2) → n__plus(X1, X2)
s(X) → n__s(X)
activate(n__0) → 0
activate(n__plus(X1, X2)) → plus(activate(X1), activate(X2))
activate(n__s(X)) → s(activate(X))
activate(X) → X

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

(22) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(0) Obligation:

(1) DependencyPairsProof (EQUIVALENT transformation)

(2) Obligation:

(3) DependencyGraphProof (EQUIVALENT transformation)

(4) Obligation:

(5) QDPOrderProof (EQUIVALENT transformation)

(6) Obligation:

(7) DependencyGraphProof (EQUIVALENT transformation)

(8) Complex Obligation (AND)

(9) Obligation:

(10) QDPOrderProof (EQUIVALENT transformation)

(11) Obligation:

(12) PisEmptyProof (EQUIVALENT transformation)

(13) TRUE

(14) Obligation:

(15) QDPOrderProof (EQUIVALENT transformation)

(16) Obligation:

(17) PisEmptyProof (EQUIVALENT transformation)

(18) TRUE

(19) Obligation:

(20) QDPOrderProof (EQUIVALENT transformation)

(21) Obligation:

(22) PisEmptyProof (EQUIVALENT transformation)

(23) TRUE