Left Termination proof of ../tpdb/LP/talp/maria/hanoiapp.pl

YES Left Termination proof of ../tpdb/LP/talp/maria/hanoiapp.pl
Left Termination of the query pattern shanoi_in_5(g, g, g, g, a) w.r.t. the given Prolog program could successfully be proven:

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

Clauses:

shanoi(1, A, B, C, .(mv(A, C), [])).
shanoi(N, A, B, C, M) :- ','(>(N, 1), ','(is(N1, -(N, 1)), ','(shanoi(N1, A, C, B, M1), ','(shanoi(N1, B, A, C, M2), ','(append(M1, .(mv(A, C), []), T), append(T, M2, M)))))).
append([], L, L).
append(.(H, L), L1, .(H, R)) :- append(L, L1, R).
demo :- ','(=(Size, 15), ','(format('Towers of Hanoi for ~w elements', .(Size, [])), ','(time(_, A), ','(nl, ','(nl, ','(shanoi(Size, a, b, c, Sol), ','(time(T, Sol), ','(format('The solution is: ~w', .(Sol, [])), ','(nl, ','(format('Solved in ~w msec.', .(T, [])), nl)))))))))).

Queries:

shanoi(g,g,g,g,a).

Added definitions of predefined predicates.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

Clauses:

shanoi(succ(zero), A, B, C, .(mv(A, C), [])).
shanoi(N, A, B, C, M) :- ','(','(=(X, N), ','(=(X1, succ(zero)), isGreater(X, X1))), ','(','(isMinus(N, succ(zero), U), =(N1, U)), ','(shanoi(N1, A, C, B, M1), ','(shanoi(N1, B, A, C, M2), ','(append(M1, .(mv(A, C), []), T), append(T, M2, M)))))).
append([], L, L).
append(.(H, L), L1, .(H, R)) :- append(L, L1, R).
demo :- ','(=(Size, succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero)))))))))))))))), ','(format('Towers of Hanoi for ~w elements', .(Size, [])), ','(time(_, A), ','(nl, ','(nl, ','(shanoi(Size, a, b, c, Sol), ','(time(T, Sol), ','(format('The solution is: ~w', .(Sol, [])), ','(nl, ','(format('Solved in ~w msec.', .(T, [])), nl)))))))))).
isPlus(zero, X, X).
isPlus(succ(X), zero, succ(X)).
isPlus(succ(X), succ(Y), succ(succ(Z))) :- isPlus(X, Y, Z).
isPlus(succ(X), pred(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), zero, pred(X)).
isPlus(pred(X), succ(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), pred(Y), pred(pred(Z))) :- isPlus(X, Y, Z).
isMinus(X, zero, X).
isMinus(zero, succ(Y), pred(Z)) :- isMinus(zero, Y, Z).
isMinus(zero, pred(Y), succ(Z)) :- isMinus(zero, Y, Z).
isMinus(succ(X), succ(Y), Z) :- isMinus(X, Y, Z).
isMinus(succ(X), pred(Y), succ(succ(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), succ(Y), pred(pred(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), pred(Y), Z) :- isMinus(X, Y, Z).
isTimes(X, zero, zero).
isTimes(zero, succ(Y), zero).
isTimes(zero, pred(Y), zero).
isTimes(succ(X), succ(Y), Z) :- ','(isTimes(succ(X), Y, A), isPlus(A, succ(X), Z)).
isTimes(succ(X), pred(Y), Z) :- ','(isTimes(succ(X), Y, A), isMinus(A, succ(X), Z)).
isTimes(pred(X), succ(Y), Z) :- ','(isTimes(pred(X), Y, A), isPlus(A, pred(X), Z)).
isTimes(pred(X), pred(Y), Z) :- ','(isTimes(pred(X), Y, A), isMinus(A, pred(X), Z)).
isDiv(zero, succ(Y), zero).
isDiv(zero, pred(Y), zero).
isDiv(succ(X), succ(Y), zero) :- isMinus(succ(X), succ(Y), pred(Z)).
isDiv(succ(X), succ(Y), succ(Z)) :- ','(isMinus(succ(X), succ(Y), A), isDiv(A, succ(Y), Z)).
isDiv(succ(X), pred(Y), Z) :- ','(isMinus(zero, pred(Y), A), ','(isDiv(succ(X), A, B), isMinus(zero, B, Z))).
isDiv(pred(X), pred(Y), zero) :- isMinus(pred(X), pred(Y), succ(Z)).
isDiv(pred(X), pred(Y), succ(Z)) :- ','(isMinus(pred(X), pred(Y), A), isDiv(A, pred(Y), Z)).
isDiv(pred(X), succ(Y), Z) :- ','(isMinus(zero, pred(X), A), ','(isDiv(A, succ(Y), B), isMinus(zero, B, Z))).
isModulo(X, Y, Z) :- ','(isDiv(X, Y, A), ','(isTimes(A, Y, B), isMinus(X, B, Z))).
=(X, X).
isGreater(succ(X), zero).
isGreater(succ(X), pred(Y)).
isGreater(succ(X), succ(Y)) :- isGreater(X, Y).
isGreater(zero, pred(Y)).
isGreater(pred(X), pred(Y)) :- isGreater(X, Y).

Queries:

shanoi(g,g,g,g,a).

Added facts for all undefined predicates.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

Clauses:

shanoi(succ(zero), A, B, C, .(mv(A, C), [])).
shanoi(N, A, B, C, M) :- ','(=(X, N), ','(=(X1, succ(zero)), ','(isGreater(X, X1), ','(isMinus(N, succ(zero), U), ','(=(N1, U), ','(shanoi(N1, A, C, B, M1), ','(shanoi(N1, B, A, C, M2), ','(append(M1, .(mv(A, C), []), T), append(T, M2, M))))))))).
append([], L, L).
append(.(H, L), L1, .(H, R)) :- append(L, L1, R).
demo :- ','(=(Size, succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero)))))))))))))))), ','(format('Towers of Hanoi for ~w elements', .(Size, [])), ','(time(X, A), ','(nl, ','(nl, ','(shanoi(Size, a, b, c, Sol), ','(time(T, Sol), ','(format('The solution is: ~w', .(Sol, [])), ','(nl, ','(format('Solved in ~w msec.', .(T, [])), nl)))))))))).
isPlus(zero, X, X).
isPlus(succ(X), zero, succ(X)).
isPlus(succ(X), succ(Y), succ(succ(Z))) :- isPlus(X, Y, Z).
isPlus(succ(X), pred(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), zero, pred(X)).
isPlus(pred(X), succ(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), pred(Y), pred(pred(Z))) :- isPlus(X, Y, Z).
isMinus(X, zero, X).
isMinus(zero, succ(Y), pred(Z)) :- isMinus(zero, Y, Z).
isMinus(zero, pred(Y), succ(Z)) :- isMinus(zero, Y, Z).
isMinus(succ(X), succ(Y), Z) :- isMinus(X, Y, Z).
isMinus(succ(X), pred(Y), succ(succ(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), succ(Y), pred(pred(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), pred(Y), Z) :- isMinus(X, Y, Z).
isTimes(X, zero, zero).
isTimes(zero, succ(Y), zero).
isTimes(zero, pred(Y), zero).
isTimes(succ(X), succ(Y), Z) :- ','(isTimes(succ(X), Y, A), isPlus(A, succ(X), Z)).
isTimes(succ(X), pred(Y), Z) :- ','(isTimes(succ(X), Y, A), isMinus(A, succ(X), Z)).
isTimes(pred(X), succ(Y), Z) :- ','(isTimes(pred(X), Y, A), isPlus(A, pred(X), Z)).
isTimes(pred(X), pred(Y), Z) :- ','(isTimes(pred(X), Y, A), isMinus(A, pred(X), Z)).
isDiv(zero, succ(Y), zero).
isDiv(zero, pred(Y), zero).
isDiv(succ(X), succ(Y), zero) :- isMinus(succ(X), succ(Y), pred(Z)).
isDiv(succ(X), succ(Y), succ(Z)) :- ','(isMinus(succ(X), succ(Y), A), isDiv(A, succ(Y), Z)).
isDiv(succ(X), pred(Y), Z) :- ','(isMinus(zero, pred(Y), A), ','(isDiv(succ(X), A, B), isMinus(zero, B, Z))).
isDiv(pred(X), pred(Y), zero) :- isMinus(pred(X), pred(Y), succ(Z)).
isDiv(pred(X), pred(Y), succ(Z)) :- ','(isMinus(pred(X), pred(Y), A), isDiv(A, pred(Y), Z)).
isDiv(pred(X), succ(Y), Z) :- ','(isMinus(zero, pred(X), A), ','(isDiv(A, succ(Y), B), isMinus(zero, B, Z))).
isModulo(X, Y, Z) :- ','(isDiv(X, Y, A), ','(isTimes(A, Y, B), isMinus(X, B, Z))).
=(X, X).
isGreater(succ(X), zero).
isGreater(succ(X), pred(Y)).
isGreater(succ(X), succ(Y)) :- isGreater(X, Y).
isGreater(zero, pred(Y)).
isGreater(pred(X), pred(Y)) :- isGreater(X, Y).
format(X0, X1).
time(X0, X1).
nl.

Queries:

shanoi(g,g,g,g,a).

We use the technique of [30]. With regard to the inferred argument filtering the predicates were used in the following modes:
shanoi_in: (b,b,b,b,f)
isGreater_in: (b,b)
isMinus_in: (b,b,f)
append_in: (b,b,f)
Transforming Prolog into the following Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

Pi-finite rewrite system:
The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

SHANOI_IN_GGGGA(N, A, B, C, M) → U1_GGGGA(N, A, B, C, M, =_in_ag(X, N))
SHANOI_IN_GGGGA(N, A, B, C, M) → =_IN_AG(X, N)
U1_GGGGA(N, A, B, C, M, =_out_ag(X, N)) → U2_GGGGA(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U1_GGGGA(N, A, B, C, M, =_out_ag(X, N)) → =_IN_AG(X1, succ(zero))
U2_GGGGA(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_GGGGA(N, A, B, C, M, isGreater_in_gg(X, X1))
U2_GGGGA(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → ISGREATER_IN_GG(X, X1)
ISGREATER_IN_GG(succ(X), succ(Y)) → U55_GG(X, Y, isGreater_in_gg(X, Y))
ISGREATER_IN_GG(succ(X), succ(Y)) → ISGREATER_IN_GG(X, Y)
ISGREATER_IN_GG(pred(X), pred(Y)) → U56_GG(X, Y, isGreater_in_gg(X, Y))
ISGREATER_IN_GG(pred(X), pred(Y)) → ISGREATER_IN_GG(X, Y)
U3_GGGGA(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_GGGGA(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
U3_GGGGA(N, A, B, C, M, isGreater_out_gg(X, X1)) → ISMINUS_IN_GGA(N, succ(zero), U)
ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) → U26_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) → ISMINUS_IN_GGA(zero, Y, Z)
ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) → U27_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) → ISMINUS_IN_GGA(zero, Y, Z)
ISMINUS_IN_GGA(succ(X), succ(Y), Z) → U28_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
ISMINUS_IN_GGA(succ(X), succ(Y), Z) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) → U29_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) → U30_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(pred(X), pred(Y), Z) → U31_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
ISMINUS_IN_GGA(pred(X), pred(Y), Z) → ISMINUS_IN_GGA(X, Y, Z)
U4_GGGGA(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_GGGGA(N, A, B, C, M, =_in_ag(N1, U))
U4_GGGGA(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → =_IN_AG(N1, U)
U5_GGGGA(N, A, B, C, M, =_out_ag(N1, U)) → U6_GGGGA(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U5_GGGGA(N, A, B, C, M, =_out_ag(N1, U)) → SHANOI_IN_GGGGA(N1, A, C, B, M1)
U6_GGGGA(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_GGGGA(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U6_GGGGA(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → SHANOI_IN_GGGGA(N1, B, A, C, M2)
U7_GGGGA(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_GGGGA(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
U7_GGGGA(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → APPEND_IN_GGA(M1, .(mv(A, C), []), T)
APPEND_IN_GGA(.(H, L), L1, .(H, R)) → U10_GGA(H, L, L1, R, append_in_gga(L, L1, R))
APPEND_IN_GGA(.(H, L), L1, .(H, R)) → APPEND_IN_GGA(L, L1, R)
U8_GGGGA(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_GGGGA(N, A, B, C, M, append_in_gga(T, M2, M))
U8_GGGGA(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → APPEND_IN_GGA(T, M2, M)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

The argument filtering Pi contains the following mapping:
shanoi_in_gggga(x1, x2, x3, x4, x5) = shanoi_in_gggga(x1, x2, x3, x4)
succ(x1) = succ(x1)
zero = zero
shanoi_out_gggga(x1, x2, x3, x4, x5) = shanoi_out_gggga(x5)
U1_gggga(x1, x2, x3, x4, x5, x6) = U1_gggga(x1, x2, x3, x4, x6)
=_in_ag(x1, x2) = =_in_ag(x2)
=_out_ag(x1, x2) = =_out_ag(x1)
U2_gggga(x1, x2, x3, x4, x5, x6, x7) = U2_gggga(x1, x2, x3, x4, x6, x7)
U3_gggga(x1, x2, x3, x4, x5, x6) = U3_gggga(x1, x2, x3, x4, x6)
isGreater_in_gg(x1, x2) = isGreater_in_gg(x1, x2)
isGreater_out_gg(x1, x2) = isGreater_out_gg
pred(x1) = pred(x1)
U55_gg(x1, x2, x3) = U55_gg(x3)
U56_gg(x1, x2, x3) = U56_gg(x3)
U4_gggga(x1, x2, x3, x4, x5, x6) = U4_gggga(x2, x3, x4, x6)
isMinus_in_gga(x1, x2, x3) = isMinus_in_gga(x1, x2)
isMinus_out_gga(x1, x2, x3) = isMinus_out_gga(x3)
U26_gga(x1, x2, x3) = U26_gga(x3)
U27_gga(x1, x2, x3) = U27_gga(x3)
U28_gga(x1, x2, x3, x4) = U28_gga(x4)
U29_gga(x1, x2, x3, x4) = U29_gga(x4)
U30_gga(x1, x2, x3, x4) = U30_gga(x4)
U31_gga(x1, x2, x3, x4) = U31_gga(x4)
U5_gggga(x1, x2, x3, x4, x5, x6) = U5_gggga(x2, x3, x4, x6)
U6_gggga(x1, x2, x3, x4, x5, x6, x7) = U6_gggga(x2, x3, x4, x6, x7)
U7_gggga(x1, x2, x3, x4, x5, x6, x7) = U7_gggga(x2, x4, x6, x7)
U8_gggga(x1, x2, x3, x4, x5, x6, x7) = U8_gggga(x6, x7)
append_in_gga(x1, x2, x3) = append_in_gga(x1, x2)
[] = []
append_out_gga(x1, x2, x3) = append_out_gga(x3)
.(x1, x2) = .(x1, x2)
U10_gga(x1, x2, x3, x4, x5) = U10_gga(x1, x5)
mv(x1, x2) = mv(x1, x2)
U9_gggga(x1, x2, x3, x4, x5, x6) = U9_gggga(x6)
U29_GGA(x1, x2, x3, x4) = U29_GGA(x4)
U7_GGGGA(x1, x2, x3, x4, x5, x6, x7) = U7_GGGGA(x2, x4, x6, x7)
U5_GGGGA(x1, x2, x3, x4, x5, x6) = U5_GGGGA(x2, x3, x4, x6)
U27_GGA(x1, x2, x3) = U27_GGA(x3)
ISGREATER_IN_GG(x1, x2) = ISGREATER_IN_GG(x1, x2)
U8_GGGGA(x1, x2, x3, x4, x5, x6, x7) = U8_GGGGA(x6, x7)
U4_GGGGA(x1, x2, x3, x4, x5, x6) = U4_GGGGA(x2, x3, x4, x6)
U26_GGA(x1, x2, x3) = U26_GGA(x3)
U55_GG(x1, x2, x3) = U55_GG(x3)
U31_GGA(x1, x2, x3, x4) = U31_GGA(x4)
U28_GGA(x1, x2, x3, x4) = U28_GGA(x4)
SHANOI_IN_GGGGA(x1, x2, x3, x4, x5) = SHANOI_IN_GGGGA(x1, x2, x3, x4)
U10_GGA(x1, x2, x3, x4, x5) = U10_GGA(x1, x5)
U1_GGGGA(x1, x2, x3, x4, x5, x6) = U1_GGGGA(x1, x2, x3, x4, x6)
U9_GGGGA(x1, x2, x3, x4, x5, x6) = U9_GGGGA(x6)
APPEND_IN_GGA(x1, x2, x3) = APPEND_IN_GGA(x1, x2)
U56_GG(x1, x2, x3) = U56_GG(x3)
ISMINUS_IN_GGA(x1, x2, x3) = ISMINUS_IN_GGA(x1, x2)
=_IN_AG(x1, x2) = =_IN_AG(x2)
U30_GGA(x1, x2, x3, x4) = U30_GGA(x4)
U2_GGGGA(x1, x2, x3, x4, x5, x6, x7) = U2_GGGGA(x1, x2, x3, x4, x6, x7)
U6_GGGGA(x1, x2, x3, x4, x5, x6, x7) = U6_GGGGA(x2, x3, x4, x6, x7)
U3_GGGGA(x1, x2, x3, x4, x5, x6) = U3_GGGGA(x1, x2, x3, x4, x6)

We have to consider all (P,R,Pi)-chains

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

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

SHANOI_IN_GGGGA(N, A, B, C, M) → U1_GGGGA(N, A, B, C, M, =_in_ag(X, N))
SHANOI_IN_GGGGA(N, A, B, C, M) → =_IN_AG(X, N)
U1_GGGGA(N, A, B, C, M, =_out_ag(X, N)) → U2_GGGGA(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U1_GGGGA(N, A, B, C, M, =_out_ag(X, N)) → =_IN_AG(X1, succ(zero))
U2_GGGGA(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_GGGGA(N, A, B, C, M, isGreater_in_gg(X, X1))
U2_GGGGA(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → ISGREATER_IN_GG(X, X1)
ISGREATER_IN_GG(succ(X), succ(Y)) → U55_GG(X, Y, isGreater_in_gg(X, Y))
ISGREATER_IN_GG(succ(X), succ(Y)) → ISGREATER_IN_GG(X, Y)
ISGREATER_IN_GG(pred(X), pred(Y)) → U56_GG(X, Y, isGreater_in_gg(X, Y))
ISGREATER_IN_GG(pred(X), pred(Y)) → ISGREATER_IN_GG(X, Y)
U3_GGGGA(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_GGGGA(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
U3_GGGGA(N, A, B, C, M, isGreater_out_gg(X, X1)) → ISMINUS_IN_GGA(N, succ(zero), U)
ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) → U26_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) → ISMINUS_IN_GGA(zero, Y, Z)
ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) → U27_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) → ISMINUS_IN_GGA(zero, Y, Z)
ISMINUS_IN_GGA(succ(X), succ(Y), Z) → U28_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
ISMINUS_IN_GGA(succ(X), succ(Y), Z) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) → U29_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) → U30_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(pred(X), pred(Y), Z) → U31_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
ISMINUS_IN_GGA(pred(X), pred(Y), Z) → ISMINUS_IN_GGA(X, Y, Z)
U4_GGGGA(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_GGGGA(N, A, B, C, M, =_in_ag(N1, U))
U4_GGGGA(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → =_IN_AG(N1, U)
U5_GGGGA(N, A, B, C, M, =_out_ag(N1, U)) → U6_GGGGA(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U5_GGGGA(N, A, B, C, M, =_out_ag(N1, U)) → SHANOI_IN_GGGGA(N1, A, C, B, M1)
U6_GGGGA(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_GGGGA(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U6_GGGGA(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → SHANOI_IN_GGGGA(N1, B, A, C, M2)
U7_GGGGA(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_GGGGA(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
U7_GGGGA(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → APPEND_IN_GGA(M1, .(mv(A, C), []), T)
APPEND_IN_GGA(.(H, L), L1, .(H, R)) → U10_GGA(H, L, L1, R, append_in_gga(L, L1, R))
APPEND_IN_GGA(.(H, L), L1, .(H, R)) → APPEND_IN_GGA(L, L1, R)
U8_GGGGA(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_GGGGA(N, A, B, C, M, append_in_gga(T, M2, M))
U8_GGGGA(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → APPEND_IN_GGA(T, M2, M)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                        ↳ UsableRulesProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

APPEND_IN_GGA(.(H, L), L1, .(H, R)) → APPEND_IN_GGA(L, L1, R)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

APPEND_IN_GGA(.(H, L), L1, .(H, R)) → APPEND_IN_GGA(L, L1, R)

R is empty.
The argument filtering Pi contains the following mapping:
.(x1, x2) = .(x1, x2)
APPEND_IN_GGA(x1, x2, x3) = APPEND_IN_GGA(x1, x2)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                              ↳ QDP

                                ↳ QDPSizeChangeProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

APPEND_IN_GGA(.(H, L), L1) → APPEND_IN_GGA(L, L1)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] 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:

APPEND_IN_GGA(.(H, L), L1) → APPEND_IN_GGA(L, L1)
The graph contains the following edges 1 > 1, 2 >= 2

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) → ISMINUS_IN_GGA(zero, Y, Z)
ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) → ISMINUS_IN_GGA(zero, Y, Z)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) → ISMINUS_IN_GGA(zero, Y, Z)
ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) → ISMINUS_IN_GGA(zero, Y, Z)

R is empty.
The argument filtering Pi contains the following mapping:
succ(x1) = succ(x1)
zero = zero
pred(x1) = pred(x1)
ISMINUS_IN_GGA(x1, x2, x3) = ISMINUS_IN_GGA(x1, x2)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                              ↳ QDP

                                ↳ QDPSizeChangeProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

ISMINUS_IN_GGA(zero, pred(Y)) → ISMINUS_IN_GGA(zero, Y)
ISMINUS_IN_GGA(zero, succ(Y)) → ISMINUS_IN_GGA(zero, Y)

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

ISMINUS_IN_GGA(zero, succ(Y)) → ISMINUS_IN_GGA(zero, Y)
The graph contains the following edges 1 >= 1, 2 > 2
ISMINUS_IN_GGA(zero, pred(Y)) → ISMINUS_IN_GGA(zero, Y)
The graph contains the following edges 1 >= 1, 2 > 2

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                      ↳ PiDP

                      ↳ PiDP

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

ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(succ(X), succ(Y), Z) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(pred(X), pred(Y), Z) → ISMINUS_IN_GGA(X, Y, Z)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                      ↳ PiDP

                      ↳ PiDP

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

ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(succ(X), succ(Y), Z) → ISMINUS_IN_GGA(X, Y, Z)
ISMINUS_IN_GGA(pred(X), pred(Y), Z) → ISMINUS_IN_GGA(X, Y, Z)

R is empty.
The argument filtering Pi contains the following mapping:
succ(x1) = succ(x1)
pred(x1) = pred(x1)
ISMINUS_IN_GGA(x1, x2, x3) = ISMINUS_IN_GGA(x1, x2)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                              ↳ QDP

                                ↳ QDPSizeChangeProof

                      ↳ PiDP

                      ↳ PiDP

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

ISMINUS_IN_GGA(succ(X), succ(Y)) → ISMINUS_IN_GGA(X, Y)
ISMINUS_IN_GGA(pred(X), pred(Y)) → ISMINUS_IN_GGA(X, Y)
ISMINUS_IN_GGA(succ(X), pred(Y)) → ISMINUS_IN_GGA(X, Y)
ISMINUS_IN_GGA(pred(X), succ(Y)) → ISMINUS_IN_GGA(X, Y)

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

ISMINUS_IN_GGA(pred(X), succ(Y)) → ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2
ISMINUS_IN_GGA(succ(X), pred(Y)) → ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2
ISMINUS_IN_GGA(succ(X), succ(Y)) → ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2
ISMINUS_IN_GGA(pred(X), pred(Y)) → ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                      ↳ PiDP

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

ISGREATER_IN_GG(succ(X), succ(Y)) → ISGREATER_IN_GG(X, Y)
ISGREATER_IN_GG(pred(X), pred(Y)) → ISGREATER_IN_GG(X, Y)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                      ↳ PiDP

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

ISGREATER_IN_GG(succ(X), succ(Y)) → ISGREATER_IN_GG(X, Y)
ISGREATER_IN_GG(pred(X), pred(Y)) → ISGREATER_IN_GG(X, Y)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                              ↳ QDP

                                ↳ QDPSizeChangeProof

                      ↳ PiDP

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

ISGREATER_IN_GG(succ(X), succ(Y)) → ISGREATER_IN_GG(X, Y)
ISGREATER_IN_GG(pred(X), pred(Y)) → ISGREATER_IN_GG(X, Y)

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

ISGREATER_IN_GG(succ(X), succ(Y)) → ISGREATER_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2
ISGREATER_IN_GG(pred(X), pred(Y)) → ISGREATER_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

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

U4_GGGGA(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_GGGGA(N, A, B, C, M, =_in_ag(N1, U))
U3_GGGGA(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_GGGGA(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
U1_GGGGA(N, A, B, C, M, =_out_ag(X, N)) → U2_GGGGA(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_GGGGA(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_GGGGA(N, A, B, C, M, isGreater_in_gg(X, X1))
U6_GGGGA(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → SHANOI_IN_GGGGA(N1, B, A, C, M2)
U5_GGGGA(N, A, B, C, M, =_out_ag(N1, U)) → SHANOI_IN_GGGGA(N1, A, C, B, M1)
U5_GGGGA(N, A, B, C, M, =_out_ag(N1, U)) → U6_GGGGA(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
SHANOI_IN_GGGGA(N, A, B, C, M) → U1_GGGGA(N, A, B, C, M, =_in_ag(X, N))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C, .(mv(A, C), [])) → shanoi_out_gggga(succ(zero), A, B, C, .(mv(A, C), []))
shanoi_in_gggga(N, A, B, C, M) → U1_gggga(N, A, B, C, M, =_in_ag(X, N))
=_in_ag(X, X) → =_out_ag(X, X)
U1_gggga(N, A, B, C, M, =_out_ag(X, N)) → U2_gggga(N, A, B, C, M, X, =_in_ag(X1, succ(zero)))
U2_gggga(N, A, B, C, M, X, =_out_ag(X1, succ(zero))) → U3_gggga(N, A, B, C, M, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg(succ(X), zero)
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg(succ(X), pred(Y))
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(X, Y, isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg(zero, pred(Y))
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(X, Y, isGreater_in_gg(X, Y))
U56_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U55_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_gggga(N, A, B, C, M, isGreater_out_gg(X, X1)) → U4_gggga(N, A, B, C, M, isMinus_in_gga(N, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U26_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U27_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U30_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U31_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U31_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U30_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U27_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U26_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_gggga(N, A, B, C, M, isMinus_out_gga(N, succ(zero), U)) → U5_gggga(N, A, B, C, M, =_in_ag(N1, U))
U5_gggga(N, A, B, C, M, =_out_ag(N1, U)) → U6_gggga(N, A, B, C, M, N1, shanoi_in_gggga(N1, A, C, B, M1))
U6_gggga(N, A, B, C, M, N1, shanoi_out_gggga(N1, A, C, B, M1)) → U7_gggga(N, A, B, C, M, M1, shanoi_in_gggga(N1, B, A, C, M2))
U7_gggga(N, A, B, C, M, M1, shanoi_out_gggga(N1, B, A, C, M2)) → U8_gggga(N, A, B, C, M, M2, append_in_gga(M1, .(mv(A, C), []), T))
append_in_gga([], L, L) → append_out_gga([], L, L)
append_in_gga(.(H, L), L1, .(H, R)) → U10_gga(H, L, L1, R, append_in_gga(L, L1, R))
U10_gga(H, L, L1, R, append_out_gga(L, L1, R)) → append_out_gga(.(H, L), L1, .(H, R))
U8_gggga(N, A, B, C, M, M2, append_out_gga(M1, .(mv(A, C), []), T)) → U9_gggga(N, A, B, C, M, append_in_gga(T, M2, M))
U9_gggga(N, A, B, C, M, append_out_gga(T, M2, M)) → shanoi_out_gggga(N, A, B, C, M)

The argument filtering Pi contains the following mapping:
shanoi_in_gggga(x1, x2, x3, x4, x5) = shanoi_in_gggga(x1, x2, x3, x4)
succ(x1) = succ(x1)
zero = zero
shanoi_out_gggga(x1, x2, x3, x4, x5) = shanoi_out_gggga(x5)
U1_gggga(x1, x2, x3, x4, x5, x6) = U1_gggga(x1, x2, x3, x4, x6)
=_in_ag(x1, x2) = =_in_ag(x2)
=_out_ag(x1, x2) = =_out_ag(x1)
U2_gggga(x1, x2, x3, x4, x5, x6, x7) = U2_gggga(x1, x2, x3, x4, x6, x7)
U3_gggga(x1, x2, x3, x4, x5, x6) = U3_gggga(x1, x2, x3, x4, x6)
isGreater_in_gg(x1, x2) = isGreater_in_gg(x1, x2)
isGreater_out_gg(x1, x2) = isGreater_out_gg
pred(x1) = pred(x1)
U55_gg(x1, x2, x3) = U55_gg(x3)
U56_gg(x1, x2, x3) = U56_gg(x3)
U4_gggga(x1, x2, x3, x4, x5, x6) = U4_gggga(x2, x3, x4, x6)
isMinus_in_gga(x1, x2, x3) = isMinus_in_gga(x1, x2)
isMinus_out_gga(x1, x2, x3) = isMinus_out_gga(x3)
U26_gga(x1, x2, x3) = U26_gga(x3)
U27_gga(x1, x2, x3) = U27_gga(x3)
U28_gga(x1, x2, x3, x4) = U28_gga(x4)
U29_gga(x1, x2, x3, x4) = U29_gga(x4)
U30_gga(x1, x2, x3, x4) = U30_gga(x4)
U31_gga(x1, x2, x3, x4) = U31_gga(x4)
U5_gggga(x1, x2, x3, x4, x5, x6) = U5_gggga(x2, x3, x4, x6)
U6_gggga(x1, x2, x3, x4, x5, x6, x7) = U6_gggga(x2, x3, x4, x6, x7)
U7_gggga(x1, x2, x3, x4, x5, x6, x7) = U7_gggga(x2, x4, x6, x7)
U8_gggga(x1, x2, x3, x4, x5, x6, x7) = U8_gggga(x6, x7)
append_in_gga(x1, x2, x3) = append_in_gga(x1, x2)
[] = []
append_out_gga(x1, x2, x3) = append_out_gga(x3)
.(x1, x2) = .(x1, x2)
U10_gga(x1, x2, x3, x4, x5) = U10_gga(x1, x5)
mv(x1, x2) = mv(x1, x2)
U9_gggga(x1, x2, x3, x4, x5, x6) = U9_gggga(x6)
U5_GGGGA(x1, x2, x3, x4, x5, x6) = U5_GGGGA(x2, x3, x4, x6)
U4_GGGGA(x1, x2, x3, x4, x5, x6) = U4_GGGGA(x2, x3, x4, x6)
SHANOI_IN_GGGGA(x1, x2, x3, x4, x5) = SHANOI_IN_GGGGA(x1, x2, x3, x4)
U1_GGGGA(x1, x2, x3, x4, x5, x6) = U1_GGGGA(x1, x2, x3, x4, x6)
U2_GGGGA(x1, x2, x3, x4, x5, x6, x7) = U2_GGGGA(x1, x2, x3, x4, x6, x7)
U6_GGGGA(x1, x2, x3, x4, x5, x6, x7) = U6_GGGGA(x2, x3, x4, x6, x7)
U3_GGGGA(x1, x2, x3, x4, x5, x6) = U3_GGGGA(x1, x2, x3, x4, x6)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

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

U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U3_GGGGA(N, A, B, C, isGreater_out_gg) → U4_GGGGA(A, B, C, isMinus_in_gga(N, succ(zero)))
U2_GGGGA(N, A, B, C, X, =_out_ag(X1)) → U3_GGGGA(N, A, B, C, isGreater_in_gg(X, X1))
U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_in_ag(U))
U1_GGGGA(N, A, B, C, =_out_ag(X)) → U2_GGGGA(N, A, B, C, X, =_in_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_in_ag(N))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_in_ag(U)) at position [3] we obtained the following new rules:

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U3_GGGGA(N, A, B, C, isGreater_out_gg) → U4_GGGGA(A, B, C, isMinus_in_gga(N, succ(zero)))
U2_GGGGA(N, A, B, C, X, =_out_ag(X1)) → U3_GGGGA(N, A, B, C, isGreater_in_gg(X, X1))
U1_GGGGA(N, A, B, C, =_out_ag(X)) → U2_GGGGA(N, A, B, C, X, =_in_ag(succ(zero)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_in_ag(N))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U1_GGGGA(N, A, B, C, =_out_ag(X)) → U2_GGGGA(N, A, B, C, X, =_in_ag(succ(zero))) at position [5] we obtained the following new rules:

U1_GGGGA(N, A, B, C, =_out_ag(X)) → U2_GGGGA(N, A, B, C, X, =_out_ag(succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U3_GGGGA(N, A, B, C, isGreater_out_gg) → U4_GGGGA(A, B, C, isMinus_in_gga(N, succ(zero)))
U2_GGGGA(N, A, B, C, X, =_out_ag(X1)) → U3_GGGGA(N, A, B, C, isGreater_in_gg(X, X1))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_in_ag(N))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U1_GGGGA(N, A, B, C, =_out_ag(X)) → U2_GGGGA(N, A, B, C, X, =_out_ag(succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_in_ag(N)) at position [4] we obtained the following new rules:

SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U3_GGGGA(N, A, B, C, isGreater_out_gg) → U4_GGGGA(A, B, C, isMinus_in_gga(N, succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U2_GGGGA(N, A, B, C, X, =_out_ag(X1)) → U3_GGGGA(N, A, B, C, isGreater_in_gg(X, X1))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U1_GGGGA(N, A, B, C, =_out_ag(X)) → U2_GGGGA(N, A, B, C, X, =_out_ag(succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U2_GGGGA(N, A, B, C, X, =_out_ag(X1)) → U3_GGGGA(N, A, B, C, isGreater_in_gg(X, X1)) we obtained the following new rules:

U2_GGGGA(z0, z1, z2, z3, z4, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z4, succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U3_GGGGA(N, A, B, C, isGreater_out_gg) → U4_GGGGA(A, B, C, isMinus_in_gga(N, succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U2_GGGGA(z0, z1, z2, z3, z4, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z4, succ(zero)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U1_GGGGA(N, A, B, C, =_out_ag(X)) → U2_GGGGA(N, A, B, C, X, =_out_ag(succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U1_GGGGA(N, A, B, C, =_out_ag(X)) → U2_GGGGA(N, A, B, C, X, =_out_ag(succ(zero))) we obtained the following new rules:

U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
U3_GGGGA(N, A, B, C, isGreater_out_gg) → U4_GGGGA(A, B, C, isMinus_in_gga(N, succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U2_GGGGA(z0, z1, z2, z3, z4, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z4, succ(zero)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U2_GGGGA(z0, z1, z2, z3, z4, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z4, succ(zero))) we obtained the following new rules:

U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U3_GGGGA(N, A, B, C, isGreater_out_gg) → U4_GGGGA(A, B, C, isMinus_in_gga(N, succ(zero)))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U3_GGGGA(N, A, B, C, isGreater_out_gg) → U4_GGGGA(A, B, C, isMinus_in_gga(N, succ(zero))) at position [3] we obtained the following new rules:

U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_in_gga(x0, zero)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_in_gga(x0, zero)))
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_in_gga(zero, zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_in_gga(x0, zero)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_in_gga(zero, zero)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_in_gga(x0, zero)))
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_in_gga(x0, zero))) at position [3,0] we obtained the following new rules:

U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_out_gga(x0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_out_gga(x0)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_in_gga(x0, zero)))
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_in_gga(zero, zero)))
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_in_gga(x0, zero))) at position [3,0] we obtained the following new rules:

U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_out_gga(x0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_out_gga(x0)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_in_gga(zero, zero)))
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_out_gga(x0)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_in_gga(zero, zero))) at position [3,0] we obtained the following new rules:

U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_out_gga(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_out_gga(zero)))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_out_gga(x0)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_out_gga(x0)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U5_GGGGA(A, B, C, =_out_ag(N1)) → U6_GGGGA(A, B, C, N1, shanoi_in_gggga(N1, A, C, B)) at position [4] we obtained the following new rules:

U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_in_ag(x0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_out_gga(zero)))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_out_gga(x0)))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_in_ag(x0)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_out_gga(x0)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U28_gga(isMinus_out_gga(x0))) at position [3] we obtained the following new rules:

U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_out_gga(zero)))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_out_gga(x0)))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_in_ag(x0)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U30_gga(isMinus_out_gga(x0))) at position [3] we obtained the following new rules:

U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(pred(x0))))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_out_gga(zero)))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_in_ag(x0)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(pred(x0))))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, U26_gga(isMinus_out_gga(zero))) at position [3] we obtained the following new rules:

U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_in_ag(x0)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(pred(x0))))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_in_ag(x0))) at position [4,4] we obtained the following new rules:

U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(zero)))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(pred(x0))))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) → U3_GGGGA(z0, z1, z2, z3, isGreater_in_gg(z0, succ(zero))) at position [4] we obtained the following new rules:

U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
U3_GGGGA(zero, y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))
U3_GGGGA(pred(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(pred(pred(x0))))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero)))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U1_GGGGA(z0, z1, z2, z3, =_out_ag(z0)) → U2_GGGGA(z0, z1, z2, z3, z0, =_out_ag(succ(zero))) we obtained the following new rules:

U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule SHANOI_IN_GGGGA(N, A, B, C) → U1_GGGGA(N, A, B, C, =_out_ag(N)) we obtained the following new rules:

SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0)))
U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B)
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U5_GGGGA(A, B, C, =_out_ag(N1)) → SHANOI_IN_GGGGA(N1, A, C, B) we obtained the following new rules:

U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C)
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U6_GGGGA(A, B, C, N1, shanoi_out_gggga(M1)) → SHANOI_IN_GGGGA(N1, B, A, C) we obtained the following new rules:

U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0)))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U5_GGGGA(x1, x3, x2, =_out_ag(x0)) → U6_GGGGA(x1, x3, x2, x0, U1_gggga(x0, x1, x2, x3, =_out_ag(x0))) we obtained the following new rules:

U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

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

U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U4_GGGGA(A, B, C, isMinus_out_gga(U)) → U5_GGGGA(A, B, C, =_out_ag(U)) we obtained the following new rules:

U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

                                                                                                                      ↳ QDP

                                                                                                                        ↳ ForwardInstantiation

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

U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U3_GGGGA(succ(x0), y1, y2, y3, isGreater_out_gg) → U4_GGGGA(y1, y2, y3, isMinus_out_gga(x0)) we obtained the following new rules:

U3_GGGGA(succ(succ(y_3)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(y_3)))
U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

                                                                                                                      ↳ QDP

                                                                                                                        ↳ ForwardInstantiation

                                                                                                                          ↳ QDP

                                                                                                                            ↳ ForwardInstantiation

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

U3_GGGGA(succ(succ(y_3)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(y_3)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(zero)))
U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U2_GGGGA(succ(x0), y1, y2, y3, succ(x0), =_out_ag(succ(zero))) → U3_GGGGA(succ(x0), y1, y2, y3, U55_gg(isGreater_in_gg(x0, zero))) we obtained the following new rules:

U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, U55_gg(isGreater_in_gg(succ(zero), zero)))
U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, U55_gg(isGreater_in_gg(succ(y_0), zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

                                                                                                                      ↳ QDP

                                                                                                                        ↳ ForwardInstantiation

                                                                                                                          ↳ QDP

                                                                                                                            ↳ ForwardInstantiation

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

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

U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, U55_gg(isGreater_in_gg(succ(zero), zero)))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)
U3_GGGGA(succ(succ(y_3)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(y_3)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, U55_gg(isGreater_in_gg(succ(y_0), zero)))
U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, U55_gg(isGreater_in_gg(succ(zero), zero))) at position [4,0] we obtained the following new rules:

U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, U55_gg(isGreater_out_gg))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

                                                                                                                      ↳ QDP

                                                                                                                        ↳ ForwardInstantiation

                                                                                                                          ↳ QDP

                                                                                                                            ↳ ForwardInstantiation

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

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

U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, U55_gg(isGreater_out_gg))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U3_GGGGA(succ(succ(y_3)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(y_3)))
U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, U55_gg(isGreater_in_gg(succ(y_0), zero)))
U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, U55_gg(isGreater_in_gg(succ(y_0), zero))) at position [4,0] we obtained the following new rules:

U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, U55_gg(isGreater_out_gg))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

                                                                                                                      ↳ QDP

                                                                                                                        ↳ ForwardInstantiation

                                                                                                                          ↳ QDP

                                                                                                                            ↳ ForwardInstantiation

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

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

U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, U55_gg(isGreater_out_gg))
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, U55_gg(isGreater_out_gg))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)
U3_GGGGA(succ(succ(y_3)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(y_3)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, U55_gg(isGreater_out_gg)) at position [4] we obtained the following new rules:

U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

                                                                                                                      ↳ QDP

                                                                                                                        ↳ ForwardInstantiation

                                                                                                                          ↳ QDP

                                                                                                                            ↳ ForwardInstantiation

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

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

U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, U55_gg(isGreater_out_gg))
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)
U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg)
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U3_GGGGA(succ(succ(y_3)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(y_3)))
U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, U55_gg(isGreater_out_gg)) at position [4] we obtained the following new rules:

U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, isGreater_out_gg)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

                                                                                                                      ↳ QDP

                                                                                                                        ↳ ForwardInstantiation

                                                                                                                          ↳ QDP

                                                                                                                            ↳ ForwardInstantiation

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ QDPOrderProof

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

U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)
U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg)
U3_GGGGA(succ(succ(y_3)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(y_3)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, isGreater_out_gg)
U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(zero)))

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

U3_GGGGA(succ(succ(y_3)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(y_3)))
U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg) → U4_GGGGA(x1, x2, x3, isMinus_out_gga(succ(zero)))

The remaining pairs can at least be oriented weakly.

U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)
U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg)
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, isGreater_out_gg)

Used ordering: Polynomial interpretation [25]:

POL(.(x₁, x₂)) = 0
POL(=_in_ag(x₁)) = 0
POL(=_out_ag(x₁)) = x₁
POL(SHANOI_IN_GGGGA(x₁, x₂, x₃, x₄)) = x₁
POL(U10_gga(x₁, x₂)) = 0
POL(U1_GGGGA(x₁, x₂, x₃, x₄, x₅)) = x₁
POL(U1_gggga(x₁, x₂, x₃, x₄, x₅)) = 0
POL(U26_gga(x₁)) = 0
POL(U27_gga(x₁)) = 0
POL(U28_gga(x₁)) = 0
POL(U29_gga(x₁)) = 0
POL(U2_GGGGA(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅
POL(U2_gggga(x₁, x₂, x₃, x₄, x₅, x₆)) = 0
POL(U30_gga(x₁)) = 0
POL(U31_gga(x₁)) = 0
POL(U3_GGGGA(x₁, x₂, x₃, x₄, x₅)) = x₁
POL(U3_gggga(x₁, x₂, x₃, x₄, x₅)) = 0
POL(U4_GGGGA(x₁, x₂, x₃, x₄)) = x₄
POL(U4_gggga(x₁, x₂, x₃, x₄)) = 0
POL(U55_gg(x₁)) = 0
POL(U56_gg(x₁)) = 0
POL(U5_GGGGA(x₁, x₂, x₃, x₄)) = x₄
POL(U5_gggga(x₁, x₂, x₃, x₄)) = 0
POL(U6_GGGGA(x₁, x₂, x₃, x₄, x₅)) = x₄
POL(U6_gggga(x₁, x₂, x₃, x₄, x₅)) = 0
POL(U7_gggga(x₁, x₂, x₃, x₄)) = 0
POL(U8_gggga(x₁, x₂)) = 0
POL(U9_gggga(x₁)) = 0
POL([]) = 0
POL(append_in_gga(x₁, x₂)) = 0
POL(append_out_gga(x₁)) = 0
POL(isGreater_in_gg(x₁, x₂)) = 0
POL(isGreater_out_gg) = 0
POL(isMinus_in_gga(x₁, x₂)) = 0
POL(isMinus_out_gga(x₁)) = x₁
POL(mv(x₁, x₂)) = 0
POL(pred(x₁)) = 0
POL(shanoi_in_gggga(x₁, x₂, x₃, x₄)) = 0
POL(shanoi_out_gggga(x₁)) = 0
POL(succ(x₁)) = 1 + x₁
POL(zero) = 0

The following usable rules [17] were oriented: none

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Narrowing

                                                                                          ↳ QDP

                                                                                            ↳ DependencyGraphProof

                                                                                              ↳ QDP

                                                                                                ↳ ForwardInstantiation

                                                                                                  ↳ QDP

                                                                                                    ↳ ForwardInstantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ ForwardInstantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ ForwardInstantiation

                                                                                                                      ↳ QDP

                                                                                                                        ↳ ForwardInstantiation

                                                                                                                          ↳ QDP

                                                                                                                            ↳ ForwardInstantiation

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Rewriting

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Rewriting

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Rewriting

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Rewriting

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ QDPOrderProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ DependencyGraphProof

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

U2_GGGGA(succ(succ(zero)), x1, x2, x3, succ(succ(zero)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(zero)), x1, x2, x3, isGreater_out_gg)
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(y_3))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3)))
SHANOI_IN_GGGGA(succ(y_0), x1, x2, x3) → U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0)))
U5_GGGGA(x0, x2, x1, =_out_ag(succ(zero))) → U6_GGGGA(x0, x2, x1, succ(zero), shanoi_out_gggga(.(mv(x0, x2), [])))
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_0))) → SHANOI_IN_GGGGA(succ(y_0), x0, x2, x1)
U5_GGGGA(x0, x1, x2, =_out_ag(succ(y_3))) → U6_GGGGA(x0, x1, x2, succ(y_3), U1_gggga(succ(y_3), x0, x2, x1, =_out_ag(succ(y_3))))
U2_GGGGA(succ(succ(y_0)), x1, x2, x3, succ(succ(y_0)), =_out_ag(succ(zero))) → U3_GGGGA(succ(succ(y_0)), x1, x2, x3, isGreater_out_gg)
U1_GGGGA(succ(y_0), x1, x2, x3, =_out_ag(succ(y_0))) → U2_GGGGA(succ(y_0), x1, x2, x3, succ(y_0), =_out_ag(succ(zero)))
U4_GGGGA(x0, x1, x2, isMinus_out_gga(succ(zero))) → U5_GGGGA(x0, x1, x2, =_out_ag(succ(zero)))
U6_GGGGA(x0, x1, x2, succ(y_0), shanoi_out_gggga(x4)) → SHANOI_IN_GGGGA(succ(y_0), x1, x0, x2)

The TRS R consists of the following rules:

shanoi_in_gggga(succ(zero), A, B, C) → shanoi_out_gggga(.(mv(A, C), []))
shanoi_in_gggga(N, A, B, C) → U1_gggga(N, A, B, C, =_in_ag(N))
=_in_ag(X) → =_out_ag(X)
U1_gggga(N, A, B, C, =_out_ag(X)) → U2_gggga(N, A, B, C, X, =_in_ag(succ(zero)))
U2_gggga(N, A, B, C, X, =_out_ag(X1)) → U3_gggga(N, A, B, C, isGreater_in_gg(X, X1))
isGreater_in_gg(succ(X), zero) → isGreater_out_gg
isGreater_in_gg(succ(X), pred(Y)) → isGreater_out_gg
isGreater_in_gg(succ(X), succ(Y)) → U55_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U56_gg(isGreater_in_gg(X, Y))
U56_gg(isGreater_out_gg) → isGreater_out_gg
U55_gg(isGreater_out_gg) → isGreater_out_gg
U3_gggga(N, A, B, C, isGreater_out_gg) → U4_gggga(A, B, C, isMinus_in_gga(N, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U26_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U27_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U28_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U29_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U30_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U31_gga(isMinus_in_gga(X, Y))
U31_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U30_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U29_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U28_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U27_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U26_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_gggga(A, B, C, isMinus_out_gga(U)) → U5_gggga(A, B, C, =_in_ag(U))
U5_gggga(A, B, C, =_out_ag(N1)) → U6_gggga(A, B, C, N1, shanoi_in_gggga(N1, A, C, B))
U6_gggga(A, B, C, N1, shanoi_out_gggga(M1)) → U7_gggga(A, C, M1, shanoi_in_gggga(N1, B, A, C))
U7_gggga(A, C, M1, shanoi_out_gggga(M2)) → U8_gggga(M2, append_in_gga(M1, .(mv(A, C), [])))
append_in_gga([], L) → append_out_gga(L)
append_in_gga(.(H, L), L1) → U10_gga(H, append_in_gga(L, L1))
U10_gga(H, append_out_gga(R)) → append_out_gga(.(H, R))
U8_gggga(M2, append_out_gga(T)) → U9_gggga(append_in_gga(T, M2))
U9_gggga(append_out_gga(M)) → shanoi_out_gggga(M)

The set Q consists of the following terms:

shanoi_in_gggga(x0, x1, x2, x3)
=_in_ag(x0)
U1_gggga(x0, x1, x2, x3, x4)
U2_gggga(x0, x1, x2, x3, x4, x5)
isGreater_in_gg(x0, x1)
U56_gg(x0)
U55_gg(x0)
U3_gggga(x0, x1, x2, x3, x4)
isMinus_in_gga(x0, x1)
U31_gga(x0)
U30_gga(x0)
U29_gga(x0)
U28_gga(x0)
U27_gga(x0)
U26_gga(x0)
U4_gggga(x0, x1, x2, x3)
U5_gggga(x0, x1, x2, x3)
U6_gggga(x0, x1, x2, x3, x4)
U7_gggga(x0, x1, x2, x3)
append_in_gga(x0, x1)
U10_gga(x0, x1)
U8_gggga(x0, x1)
U9_gggga(x0)

We have to consider all (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 10 less nodes.