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

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

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

Clauses:

fib(0, 0).
fib(1, 1).
fib(M, N) :- ','(>(M, 1), ','(is(M1, -(M, 1)), ','(is(M2, -(M, 2)), ','(fib(M1, N1), ','(fib(M2, N2), is(N, +(N1, N2))))))).
no_trace_main :- ','(time(_), ','(fib(15, M), ','(time(T), ','(write('Executed in '), ','(write(T), ','(write(' mS.'), ','(nl, ','(write('Result '), ','(write(M), nl))))))))).
trace_main(Eventfile) :- ','(start_event_trace, ','(fib(15, M), ','(stop_event_trace, ','(save_trace(Eventfile), ','(write('Result '), ','(write(M), nl)))))).
save_trace(X) :- ','(write('Saving trace in file '), ','(write(X), ','(write('... '), ','(open(X, write, Y), ','(save_event_trace(Y), ','(close(X), ','(write('done.'), nl))))))).
time(T) :- statistics(runtime, .(_, .(T, []))).

Queries:

fib(g,a).

Added definitions of predefined predicates.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

Clauses:

fib(zero, zero).
fib(succ(zero), succ(zero)).
fib(M, N) :- ','(','(=(X, M), ','(=(X1, succ(zero)), isGreater(X, X1))), ','(','(isMinus(M, succ(zero), U), =(M1, U)), ','(','(isMinus(M, succ(succ(zero)), U), =(M2, U)), ','(fib(M1, N1), ','(fib(M2, N2), ','(isPlus(N1, N2, U), =(N, U))))))).
no_trace_main :- ','(time(_), ','(fib(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero))))))))))))))), M), ','(time(T), ','(write('Executed in '), ','(write(T), ','(write(' mS.'), ','(nl, ','(write('Result '), ','(write(M), nl))))))))).
trace_main(Eventfile) :- ','(start_event_trace, ','(fib(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero))))))))))))))), M), ','(stop_event_trace, ','(save_trace(Eventfile), ','(write('Result '), ','(write(M), nl)))))).
save_trace(X) :- ','(write('Saving trace in file '), ','(write(X), ','(write('... '), ','(open(X, write, Y), ','(save_event_trace(Y), ','(close(X), ','(write('done.'), nl))))))).
time(T) :- statistics(runtime, .(_, .(T, []))).
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:

fib(g,a).

Added facts for all undefined predicates.

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

Clauses:

fib(zero, zero).
fib(succ(zero), succ(zero)).
fib(M, N) :- ','(=(X, M), ','(=(X1, succ(zero)), ','(isGreater(X, X1), ','(isMinus(M, succ(zero), U), ','(=(M1, U), ','(isMinus(M, succ(succ(zero)), U), ','(=(M2, U), ','(fib(M1, N1), ','(fib(M2, N2), ','(isPlus(N1, N2, U), =(N, U))))))))))).
no_trace_main :- ','(time(X), ','(fib(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero))))))))))))))), M), ','(time(T), ','(write('Executed in '), ','(write(T), ','(write(' mS.'), ','(nl, ','(write('Result '), ','(write(M), nl))))))))).
trace_main(Eventfile) :- ','(start_event_trace, ','(fib(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero))))))))))))))), M), ','(stop_event_trace, ','(save_trace(Eventfile), ','(write('Result '), ','(write(M), nl)))))).
save_trace(X) :- ','(write('Saving trace in file '), ','(write(X), ','(write('... '), ','(open(X, write, Y), ','(save_event_trace(Y), ','(close(X), ','(write('done.'), nl))))))).
time(T) :- statistics(runtime, .(X, .(T, []))).
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).
write(X0).
nl.
start_event_trace.
stop_event_trace.
open(X0, X1, X2).
save_event_trace(X0).
close(X0).
statistics(X0, X1).

Queries:

fib(g,a).

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

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

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:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

FIB_IN_GA(M, N) → U1_GA(M, N, =_in_ag(X, M))
FIB_IN_GA(M, N) → =_IN_AG(X, M)
U1_GA(M, N, =_out_ag(X, M)) → U2_GA(M, N, X, =_in_ag(X1, succ(zero)))
U1_GA(M, N, =_out_ag(X, M)) → =_IN_AG(X1, succ(zero))
U2_GA(M, N, X, =_out_ag(X1, succ(zero))) → U3_GA(M, N, isGreater_in_gg(X, X1))
U2_GA(M, N, X, =_out_ag(X1, succ(zero))) → ISGREATER_IN_GG(X, X1)
ISGREATER_IN_GG(succ(X), succ(Y)) → U71_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)) → U72_GG(X, Y, isGreater_in_gg(X, Y))
ISGREATER_IN_GG(pred(X), pred(Y)) → ISGREATER_IN_GG(X, Y)
U3_GA(M, N, isGreater_out_gg(X, X1)) → U4_GA(M, N, isMinus_in_gga(M, succ(zero), U))
U3_GA(M, N, isGreater_out_gg(X, X1)) → ISMINUS_IN_GGA(M, succ(zero), U)
ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) → U42_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)) → U43_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) → U44_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))) → U45_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))) → U46_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) → U47_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_GA(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_GA(M, N, U, =_in_ag(M1, U))
U4_GA(M, N, isMinus_out_gga(M, succ(zero), U)) → =_IN_AG(M1, U)
U5_GA(M, N, U, =_out_ag(M1, U)) → U6_GA(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U5_GA(M, N, U, =_out_ag(M1, U)) → ISMINUS_IN_GGG(M, succ(succ(zero)), U)
ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) → U42_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) → ISMINUS_IN_GGG(zero, Y, Z)
ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) → U43_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) → ISMINUS_IN_GGG(zero, Y, Z)
ISMINUS_IN_GGG(succ(X), succ(Y), Z) → U44_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
ISMINUS_IN_GGG(succ(X), succ(Y), Z) → ISMINUS_IN_GGG(X, Y, Z)
ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) → U45_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) → ISMINUS_IN_GGG(X, Y, Z)
ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) → U46_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) → ISMINUS_IN_GGG(X, Y, Z)
ISMINUS_IN_GGG(pred(X), pred(Y), Z) → U47_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
ISMINUS_IN_GGG(pred(X), pred(Y), Z) → ISMINUS_IN_GGG(X, Y, Z)
U6_GA(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_GA(M, N, U, M1, =_in_ag(M2, U))
U6_GA(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → =_IN_AG(M2, U)
U7_GA(M, N, U, M1, =_out_ag(M2, U)) → U8_GA(M, N, U, M2, fib_in_ga(M1, N1))
U7_GA(M, N, U, M1, =_out_ag(M2, U)) → FIB_IN_GA(M1, N1)
U8_GA(M, N, U, M2, fib_out_ga(M1, N1)) → U9_GA(M, N, U, N1, fib_in_ga(M2, N2))
U8_GA(M, N, U, M2, fib_out_ga(M1, N1)) → FIB_IN_GA(M2, N2)
U9_GA(M, N, U, N1, fib_out_ga(M2, N2)) → U10_GA(M, N, U, isPlus_in_ggg(N1, N2, U))
U9_GA(M, N, U, N1, fib_out_ga(M2, N2)) → ISPLUS_IN_GGG(N1, N2, U)
ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) → U38_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) → ISPLUS_IN_GGG(X, Y, Z)
ISPLUS_IN_GGG(succ(X), pred(Y), Z) → U39_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
ISPLUS_IN_GGG(succ(X), pred(Y), Z) → ISPLUS_IN_GGG(X, Y, Z)
ISPLUS_IN_GGG(pred(X), succ(Y), Z) → U40_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
ISPLUS_IN_GGG(pred(X), succ(Y), Z) → ISPLUS_IN_GGG(X, Y, Z)
ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) → U41_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) → ISPLUS_IN_GGG(X, Y, Z)
U10_GA(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_GA(M, N, =_in_ag(N, U))
U10_GA(M, N, U, isPlus_out_ggg(N1, N2, U)) → =_IN_AG(N, U)

The TRS R consists of the following rules:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

The argument filtering Pi contains the following mapping:
fib_in_ga(x1, x2) = fib_in_ga(x1)
zero = zero
fib_out_ga(x1, x2) = fib_out_ga(x2)
succ(x1) = succ(x1)
U1_ga(x1, x2, x3) = U1_ga(x1, x3)
=_in_ag(x1, x2) = =_in_ag(x2)
=_out_ag(x1, x2) = =_out_ag(x1)
U2_ga(x1, x2, x3, x4) = U2_ga(x1, x3, x4)
U3_ga(x1, x2, x3) = U3_ga(x1, x3)
isGreater_in_gg(x1, x2) = isGreater_in_gg(x1, x2)
isGreater_out_gg(x1, x2) = isGreater_out_gg
pred(x1) = pred(x1)
U71_gg(x1, x2, x3) = U71_gg(x3)
U72_gg(x1, x2, x3) = U72_gg(x3)
U4_ga(x1, x2, x3) = U4_ga(x1, x3)
isMinus_in_gga(x1, x2, x3) = isMinus_in_gga(x1, x2)
isMinus_out_gga(x1, x2, x3) = isMinus_out_gga(x3)
U42_gga(x1, x2, x3) = U42_gga(x3)
U43_gga(x1, x2, x3) = U43_gga(x3)
U44_gga(x1, x2, x3, x4) = U44_gga(x4)
U45_gga(x1, x2, x3, x4) = U45_gga(x4)
U46_gga(x1, x2, x3, x4) = U46_gga(x4)
U47_gga(x1, x2, x3, x4) = U47_gga(x4)
U5_ga(x1, x2, x3, x4) = U5_ga(x1, x3, x4)
U6_ga(x1, x2, x3, x4, x5) = U6_ga(x3, x4, x5)
isMinus_in_ggg(x1, x2, x3) = isMinus_in_ggg(x1, x2, x3)
isMinus_out_ggg(x1, x2, x3) = isMinus_out_ggg
U42_ggg(x1, x2, x3) = U42_ggg(x3)
U43_ggg(x1, x2, x3) = U43_ggg(x3)
U44_ggg(x1, x2, x3, x4) = U44_ggg(x4)
U45_ggg(x1, x2, x3, x4) = U45_ggg(x4)
U46_ggg(x1, x2, x3, x4) = U46_ggg(x4)
U47_ggg(x1, x2, x3, x4) = U47_ggg(x4)
U7_ga(x1, x2, x3, x4, x5) = U7_ga(x3, x4, x5)
U8_ga(x1, x2, x3, x4, x5) = U8_ga(x3, x4, x5)
U9_ga(x1, x2, x3, x4, x5) = U9_ga(x3, x4, x5)
U10_ga(x1, x2, x3, x4) = U10_ga(x3, x4)
isPlus_in_ggg(x1, x2, x3) = isPlus_in_ggg(x1, x2, x3)
isPlus_out_ggg(x1, x2, x3) = isPlus_out_ggg
U38_ggg(x1, x2, x3, x4) = U38_ggg(x4)
U39_ggg(x1, x2, x3, x4) = U39_ggg(x4)
U40_ggg(x1, x2, x3, x4) = U40_ggg(x4)
U41_ggg(x1, x2, x3, x4) = U41_ggg(x4)
U11_ga(x1, x2, x3) = U11_ga(x3)
U42_GGA(x1, x2, x3) = U42_GGA(x3)
ISGREATER_IN_GG(x1, x2) = ISGREATER_IN_GG(x1, x2)
U45_GGA(x1, x2, x3, x4) = U45_GGA(x4)
U39_GGG(x1, x2, x3, x4) = U39_GGG(x4)
U38_GGG(x1, x2, x3, x4) = U38_GGG(x4)
U44_GGA(x1, x2, x3, x4) = U44_GGA(x4)
U71_GG(x1, x2, x3) = U71_GG(x3)
U41_GGG(x1, x2, x3, x4) = U41_GGG(x4)
U46_GGG(x1, x2, x3, x4) = U46_GGG(x4)
ISMINUS_IN_GGG(x1, x2, x3) = ISMINUS_IN_GGG(x1, x2, x3)
U6_GA(x1, x2, x3, x4, x5) = U6_GA(x3, x4, x5)
ISMINUS_IN_GGA(x1, x2, x3) = ISMINUS_IN_GGA(x1, x2)
U43_GGG(x1, x2, x3) = U43_GGG(x3)
=_IN_AG(x1, x2) = =_IN_AG(x2)
U40_GGG(x1, x2, x3, x4) = U40_GGG(x4)
U1_GA(x1, x2, x3) = U1_GA(x1, x3)
U42_GGG(x1, x2, x3) = U42_GGG(x3)
U43_GGA(x1, x2, x3) = U43_GGA(x3)
U46_GGA(x1, x2, x3, x4) = U46_GGA(x4)
U8_GA(x1, x2, x3, x4, x5) = U8_GA(x3, x4, x5)
U7_GA(x1, x2, x3, x4, x5) = U7_GA(x3, x4, x5)
FIB_IN_GA(x1, x2) = FIB_IN_GA(x1)
U44_GGG(x1, x2, x3, x4) = U44_GGG(x4)
ISPLUS_IN_GGG(x1, x2, x3) = ISPLUS_IN_GGG(x1, x2, x3)
U4_GA(x1, x2, x3) = U4_GA(x1, x3)
U2_GA(x1, x2, x3, x4) = U2_GA(x1, x3, x4)
U47_GGG(x1, x2, x3, x4) = U47_GGG(x4)
U45_GGG(x1, x2, x3, x4) = U45_GGG(x4)
U72_GG(x1, x2, x3) = U72_GG(x3)
U47_GGA(x1, x2, x3, x4) = U47_GGA(x4)
U10_GA(x1, x2, x3, x4) = U10_GA(x3, x4)
U5_GA(x1, x2, x3, x4) = U5_GA(x1, x3, x4)
U11_GA(x1, x2, x3) = U11_GA(x3)
U3_GA(x1, x2, x3) = U3_GA(x1, x3)
U9_GA(x1, x2, x3, x4, x5) = U9_GA(x3, x4, x5)

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:

FIB_IN_GA(M, N) → U1_GA(M, N, =_in_ag(X, M))
FIB_IN_GA(M, N) → =_IN_AG(X, M)
U1_GA(M, N, =_out_ag(X, M)) → U2_GA(M, N, X, =_in_ag(X1, succ(zero)))
U1_GA(M, N, =_out_ag(X, M)) → =_IN_AG(X1, succ(zero))
U2_GA(M, N, X, =_out_ag(X1, succ(zero))) → U3_GA(M, N, isGreater_in_gg(X, X1))
U2_GA(M, N, X, =_out_ag(X1, succ(zero))) → ISGREATER_IN_GG(X, X1)
ISGREATER_IN_GG(succ(X), succ(Y)) → U71_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)) → U72_GG(X, Y, isGreater_in_gg(X, Y))
ISGREATER_IN_GG(pred(X), pred(Y)) → ISGREATER_IN_GG(X, Y)
U3_GA(M, N, isGreater_out_gg(X, X1)) → U4_GA(M, N, isMinus_in_gga(M, succ(zero), U))
U3_GA(M, N, isGreater_out_gg(X, X1)) → ISMINUS_IN_GGA(M, succ(zero), U)
ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) → U42_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)) → U43_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) → U44_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))) → U45_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))) → U46_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) → U47_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_GA(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_GA(M, N, U, =_in_ag(M1, U))
U4_GA(M, N, isMinus_out_gga(M, succ(zero), U)) → =_IN_AG(M1, U)
U5_GA(M, N, U, =_out_ag(M1, U)) → U6_GA(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U5_GA(M, N, U, =_out_ag(M1, U)) → ISMINUS_IN_GGG(M, succ(succ(zero)), U)
ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) → U42_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) → ISMINUS_IN_GGG(zero, Y, Z)
ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) → U43_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) → ISMINUS_IN_GGG(zero, Y, Z)
ISMINUS_IN_GGG(succ(X), succ(Y), Z) → U44_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
ISMINUS_IN_GGG(succ(X), succ(Y), Z) → ISMINUS_IN_GGG(X, Y, Z)
ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) → U45_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) → ISMINUS_IN_GGG(X, Y, Z)
ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) → U46_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) → ISMINUS_IN_GGG(X, Y, Z)
ISMINUS_IN_GGG(pred(X), pred(Y), Z) → U47_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
ISMINUS_IN_GGG(pred(X), pred(Y), Z) → ISMINUS_IN_GGG(X, Y, Z)
U6_GA(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_GA(M, N, U, M1, =_in_ag(M2, U))
U6_GA(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → =_IN_AG(M2, U)
U7_GA(M, N, U, M1, =_out_ag(M2, U)) → U8_GA(M, N, U, M2, fib_in_ga(M1, N1))
U7_GA(M, N, U, M1, =_out_ag(M2, U)) → FIB_IN_GA(M1, N1)
U8_GA(M, N, U, M2, fib_out_ga(M1, N1)) → U9_GA(M, N, U, N1, fib_in_ga(M2, N2))
U8_GA(M, N, U, M2, fib_out_ga(M1, N1)) → FIB_IN_GA(M2, N2)
U9_GA(M, N, U, N1, fib_out_ga(M2, N2)) → U10_GA(M, N, U, isPlus_in_ggg(N1, N2, U))
U9_GA(M, N, U, N1, fib_out_ga(M2, N2)) → ISPLUS_IN_GGG(N1, N2, U)
ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) → U38_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) → ISPLUS_IN_GGG(X, Y, Z)
ISPLUS_IN_GGG(succ(X), pred(Y), Z) → U39_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
ISPLUS_IN_GGG(succ(X), pred(Y), Z) → ISPLUS_IN_GGG(X, Y, Z)
ISPLUS_IN_GGG(pred(X), succ(Y), Z) → U40_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
ISPLUS_IN_GGG(pred(X), succ(Y), Z) → ISPLUS_IN_GGG(X, Y, Z)
ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) → U41_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) → ISPLUS_IN_GGG(X, Y, Z)
U10_GA(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_GA(M, N, =_in_ag(N, U))
U10_GA(M, N, U, isPlus_out_ggg(N1, N2, U)) → =_IN_AG(N, U)

The TRS R consists of the following rules:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                        ↳ UsableRulesProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

The TRS R consists of the following rules:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

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

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                              ↳ QDP

                                ↳ QDPSizeChangeProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

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:

ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) → ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3
ISPLUS_IN_GGG(pred(X), succ(Y), Z) → ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3
ISPLUS_IN_GGG(succ(X), pred(Y), Z) → ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3
ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) → ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

The TRS R consists of the following rules:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

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

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                              ↳ QDP

                                ↳ QDPSizeChangeProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

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

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

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

The TRS R consists of the following rules:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

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

                        ↳ UsableRulesProof

                          ↳ PiDP

                            ↳ PiDPToQDPProof

                              ↳ QDP

                                ↳ QDPSizeChangeProof

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

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

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

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

ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) → ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3
ISMINUS_IN_GGG(pred(X), pred(Y), Z) → ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3
ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) → ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3
ISMINUS_IN_GGG(succ(X), succ(Y), Z) → ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ 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:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ 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:
zero = zero
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

                      ↳ 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

                      ↳ 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:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ 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

                      ↳ 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

                      ↳ 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:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ 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

                      ↳ 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

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

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

U4_GA(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_GA(M, N, U, =_in_ag(M1, U))
U1_GA(M, N, =_out_ag(X, M)) → U2_GA(M, N, X, =_in_ag(X1, succ(zero)))
U8_GA(M, N, U, M2, fib_out_ga(M1, N1)) → FIB_IN_GA(M2, N2)
U6_GA(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_GA(M, N, U, M1, =_in_ag(M2, U))
FIB_IN_GA(M, N) → U1_GA(M, N, =_in_ag(X, M))
U7_GA(M, N, U, M1, =_out_ag(M2, U)) → U8_GA(M, N, U, M2, fib_in_ga(M1, N1))
U2_GA(M, N, X, =_out_ag(X1, succ(zero))) → U3_GA(M, N, isGreater_in_gg(X, X1))
U7_GA(M, N, U, M1, =_out_ag(M2, U)) → FIB_IN_GA(M1, N1)
U3_GA(M, N, isGreater_out_gg(X, X1)) → U4_GA(M, N, isMinus_in_gga(M, succ(zero), U))
U5_GA(M, N, U, =_out_ag(M1, U)) → U6_GA(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))

The TRS R consists of the following rules:

fib_in_ga(zero, zero) → fib_out_ga(zero, zero)
fib_in_ga(succ(zero), succ(zero)) → fib_out_ga(succ(zero), succ(zero))
fib_in_ga(M, N) → U1_ga(M, N, =_in_ag(X, M))
=_in_ag(X, X) → =_out_ag(X, X)
U1_ga(M, N, =_out_ag(X, M)) → U2_ga(M, N, X, =_in_ag(X1, succ(zero)))
U2_ga(M, N, X, =_out_ag(X1, succ(zero))) → U3_ga(M, N, 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)) → U71_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)) → U72_gg(X, Y, isGreater_in_gg(X, Y))
U72_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(pred(X), pred(Y))
U71_gg(X, Y, isGreater_out_gg(X, Y)) → isGreater_out_gg(succ(X), succ(Y))
U3_ga(M, N, isGreater_out_gg(X, X1)) → U4_ga(M, N, isMinus_in_gga(M, succ(zero), U))
isMinus_in_gga(X, zero, X) → isMinus_out_gga(X, zero, X)
isMinus_in_gga(zero, succ(Y), pred(Z)) → U42_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(zero, pred(Y), succ(Z)) → U43_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
isMinus_in_gga(succ(X), succ(Y), Z) → U44_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) → U45_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) → U46_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
isMinus_in_gga(pred(X), pred(Y), Z) → U47_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
U47_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), pred(Y), Z)
U46_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
U45_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
U44_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) → isMinus_out_gga(succ(X), succ(Y), Z)
U43_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, pred(Y), succ(Z))
U42_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) → isMinus_out_gga(zero, succ(Y), pred(Z))
U4_ga(M, N, isMinus_out_gga(M, succ(zero), U)) → U5_ga(M, N, U, =_in_ag(M1, U))
U5_ga(M, N, U, =_out_ag(M1, U)) → U6_ga(M, N, U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg(X, zero, X)
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
U47_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), pred(Y), Z)
U46_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
U45_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
U44_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) → isMinus_out_ggg(succ(X), succ(Y), Z)
U43_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, pred(Y), succ(Z))
U42_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) → isMinus_out_ggg(zero, succ(Y), pred(Z))
U6_ga(M, N, U, M1, isMinus_out_ggg(M, succ(succ(zero)), U)) → U7_ga(M, N, U, M1, =_in_ag(M2, U))
U7_ga(M, N, U, M1, =_out_ag(M2, U)) → U8_ga(M, N, U, M2, fib_in_ga(M1, N1))
U8_ga(M, N, U, M2, fib_out_ga(M1, N1)) → U9_ga(M, N, U, N1, fib_in_ga(M2, N2))
U9_ga(M, N, U, N1, fib_out_ga(M2, N2)) → U10_ga(M, N, U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg(zero, X, X)
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg(succ(X), zero, succ(X))
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg(pred(X), zero, pred(X))
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
U41_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
U40_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(pred(X), succ(Y), Z)
U39_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), pred(Y), Z)
U38_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) → isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
U10_ga(M, N, U, isPlus_out_ggg(N1, N2, U)) → U11_ga(M, N, =_in_ag(N, U))
U11_ga(M, N, =_out_ag(N, U)) → fib_out_ga(M, N)

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

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

U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_in_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → U8_GA(U, M2, fib_in_ga(M1))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_in_ag(U))
FIB_IN_GA(M) → U1_GA(M, =_in_ag(M))
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_in_ag(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U2_GA(M, X, =_out_ag(X1)) → U3_GA(M, isGreater_in_gg(X, X1))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_in_ag(U)) at position [2] we obtained the following new rules:

U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

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

U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_in_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → U8_GA(U, M2, fib_in_ga(M1))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
FIB_IN_GA(M) → U1_GA(M, =_in_ag(M))
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_in_ag(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U2_GA(M, X, =_out_ag(X1)) → U3_GA(M, isGreater_in_gg(X, X1))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_in_ag(succ(zero))) at position [2] we obtained the following new rules:

U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

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

U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_in_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → U8_GA(U, M2, fib_in_ga(M1))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
FIB_IN_GA(M) → U1_GA(M, =_in_ag(M))
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U2_GA(M, X, =_out_ag(X1)) → U3_GA(M, isGreater_in_gg(X, X1))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_in_ag(U)) at position [2] we obtained the following new rules:

U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

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

U7_GA(U, M1, =_out_ag(M2)) → U8_GA(U, M2, fib_in_ga(M1))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
FIB_IN_GA(M) → U1_GA(M, =_in_ag(M))
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U2_GA(M, X, =_out_ag(X1)) → U3_GA(M, isGreater_in_gg(X, X1))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule FIB_IN_GA(M) → U1_GA(M, =_in_ag(M)) at position [1] we obtained the following new rules:

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

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

U7_GA(U, M1, =_out_ag(M2)) → U8_GA(U, M2, fib_in_ga(M1))
FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U2_GA(M, X, =_out_ag(X1)) → U3_GA(M, isGreater_in_gg(X, X1))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U7_GA(U, M1, =_out_ag(M2)) → U8_GA(U, M2, fib_in_ga(M1)) at position [2] we obtained the following new rules:

U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_in_ag(x0)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_in_ag(x0)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U2_GA(M, X, =_out_ag(X1)) → U3_GA(M, isGreater_in_gg(X, X1))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_in_ag(x0))) at position [2,1] we obtained the following new rules:

U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U2_GA(M, X, =_out_ag(X1)) → U3_GA(M, isGreater_in_gg(X, X1))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U2_GA(M, X, =_out_ag(X1)) → U3_GA(M, isGreater_in_gg(X, X1)) at position [1] we obtained the following new rules:

U2_GA(y0, pred(x0), =_out_ag(pred(x1))) → U3_GA(y0, U72_gg(isGreater_in_gg(x0, x1)))
U2_GA(y0, zero, =_out_ag(pred(x0))) → U3_GA(y0, isGreater_out_gg)
U2_GA(y0, succ(x0), =_out_ag(pred(x1))) → U3_GA(y0, isGreater_out_gg)
U2_GA(y0, succ(x0), =_out_ag(zero)) → U3_GA(y0, isGreater_out_gg)
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U2_GA(y0, zero, =_out_ag(pred(x0))) → U3_GA(y0, isGreater_out_gg)
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U2_GA(y0, succ(x0), =_out_ag(zero)) → U3_GA(y0, isGreater_out_gg)
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U2_GA(y0, succ(x0), =_out_ag(pred(x1))) → U3_GA(y0, isGreater_out_gg)
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U2_GA(y0, pred(x0), =_out_ag(pred(x1))) → U3_GA(y0, U72_gg(isGreater_in_gg(x0, x1)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

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

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

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

U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U3_GA(M, isGreater_out_gg) → U4_GA(M, isMinus_in_gga(M, succ(zero))) at position [1] we obtained the following new rules:

U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_in_gga(x0, zero)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_in_gga(x0, zero)))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_in_gga(zero, zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_in_gga(x0, zero)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_in_gga(x0, zero)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_in_gga(zero, zero)))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_in_gga(x0, zero))) at position [1,0] we obtained the following new rules:

U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_out_gga(x0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_out_gga(x0)))
U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_in_gga(x0, zero)))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_in_gga(zero, zero)))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U5_GA(M, U, =_out_ag(M1)) → U6_GA(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U)) at position [2] we obtained the following new rules:

U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_in_gga(x0, zero)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_out_gga(x0)))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_in_gga(zero, zero)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_in_gga(x0, zero))) at position [1,0] we obtained the following new rules:

U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_out_gga(x0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_out_gga(x0)))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_out_gga(x0)))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_in_gga(zero, zero)))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_in_gga(zero, zero))) at position [1,0] we obtained the following new rules:

U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_out_gga(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_out_gga(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_out_gga(x0)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_out_gga(x0)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U1_GA(M, =_out_ag(X)) → U2_GA(M, X, =_out_ag(succ(zero))) we obtained the following new rules:

U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_out_gga(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_out_gga(x0)))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_out_gga(x0)))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), U46_gga(isMinus_out_gga(x0))) at position [1] we obtained the following new rules:

U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), isMinus_out_gga(pred(pred(x0))))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_out_gga(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), isMinus_out_gga(pred(pred(x0))))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_out_gga(x0)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By rewriting [15] the rule U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), U44_gga(isMinus_out_gga(x0))) at position [1] we obtained the following new rules:

U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), isMinus_out_gga(x0))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_out_gga(zero)))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), isMinus_out_gga(pred(pred(x0))))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), isMinus_out_gga(x0))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U2_GA(y0, succ(x0), =_out_ag(succ(x1))) → U3_GA(y0, U71_gg(isGreater_in_gg(x0, x1))) we obtained the following new rules:

U2_GA(succ(x1), succ(x1), =_out_ag(succ(zero))) → U3_GA(succ(x1), U71_gg(isGreater_in_gg(x1, zero)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ DependencyGraphProof

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U2_GA(succ(x1), succ(x1), =_out_ag(succ(zero))) → U3_GA(succ(x1), U71_gg(isGreater_in_gg(x1, zero)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U3_GA(zero, isGreater_out_gg) → U4_GA(zero, U42_gga(isMinus_out_gga(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(pred(x0), isGreater_out_gg) → U4_GA(pred(x0), isMinus_out_gga(pred(pred(x0))))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), isMinus_out_gga(x0))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(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

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ DependencyGraphProof

                                                                                                  ↳ QDP

                                                                                                    ↳ Instantiation

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U2_GA(succ(x1), succ(x1), =_out_ag(succ(zero))) → U3_GA(succ(x1), U71_gg(isGreater_in_gg(x1, zero)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), isMinus_out_gga(x0))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U4_GA(M, isMinus_out_gga(U)) → U5_GA(M, U, =_out_ag(U)) we obtained the following new rules:

U4_GA(succ(z0), isMinus_out_gga(z0)) → U5_GA(succ(z0), z0, =_out_ag(z0))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ DependencyGraphProof

                                                                                                  ↳ QDP

                                                                                                    ↳ Instantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U2_GA(succ(x1), succ(x1), =_out_ag(succ(zero))) → U3_GA(succ(x1), U71_gg(isGreater_in_gg(x1, zero)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U5_GA(pred(x0), pred(pred(x2)), =_out_ag(y2)) → U6_GA(pred(pred(x2)), y2, U46_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), isMinus_out_gga(x0))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U4_GA(succ(z0), isMinus_out_gga(z0)) → U5_GA(succ(z0), z0, =_out_ag(z0))
U5_GA(zero, pred(x1), =_out_ag(y2)) → U6_GA(pred(x1), y2, U42_ggg(isMinus_in_ggg(zero, succ(zero), x1)))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(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

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ DependencyGraphProof

                                                                                                  ↳ QDP

                                                                                                    ↳ Instantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Instantiation

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

U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), isMinus_out_gga(x0))
U2_GA(succ(x1), succ(x1), =_out_ag(succ(zero))) → U3_GA(succ(x1), U71_gg(isGreater_in_gg(x1, zero)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U4_GA(succ(z0), isMinus_out_gga(z0)) → U5_GA(succ(z0), z0, =_out_ag(z0))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By instantiating [15] the rule U5_GA(succ(x0), x2, =_out_ag(y2)) → U6_GA(x2, y2, U44_ggg(isMinus_in_ggg(x0, succ(zero), x2))) we obtained the following new rules:

U5_GA(succ(z0), z0, =_out_ag(z0)) → U6_GA(z0, z0, U44_ggg(isMinus_in_ggg(z0, succ(zero), z0)))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ DependencyGraphProof

                                                                                                  ↳ QDP

                                                                                                    ↳ Instantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Instantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U2_GA(succ(x1), succ(x1), =_out_ag(succ(zero))) → U3_GA(succ(x1), U71_gg(isGreater_in_gg(x1, zero)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), isMinus_out_gga(x0))
U5_GA(succ(z0), z0, =_out_ag(z0)) → U6_GA(z0, z0, U44_ggg(isMinus_in_ggg(z0, succ(zero), z0)))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U4_GA(succ(z0), isMinus_out_gga(z0)) → U5_GA(succ(z0), z0, =_out_ag(z0))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U5_GA(succ(z0), z0, =_out_ag(z0)) → U6_GA(z0, z0, U44_ggg(isMinus_in_ggg(z0, succ(zero), z0))) at position [2] we obtained the following new rules:

U5_GA(succ(succ(x0)), succ(x0), =_out_ag(succ(x0))) → U6_GA(succ(x0), succ(x0), U44_ggg(U44_ggg(isMinus_in_ggg(x0, zero, succ(x0)))))
U5_GA(succ(pred(pred(x2))), pred(pred(x2)), =_out_ag(pred(pred(x2)))) → U6_GA(pred(pred(x2)), pred(pred(x2)), U44_ggg(U46_ggg(isMinus_in_ggg(pred(x2), zero, x2))))

↳ Prolog

  ↳ PredefinedPredicateTransformerProof

    ↳ Prolog

      ↳ UndefinedPredicateHandlerProof

        ↳ Prolog

          ↳ PrologToPiTRSProof

            ↳ PiTRS

              ↳ DependencyPairsProof

                ↳ PiDP

                  ↳ DependencyGraphProof

                    ↳ AND

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                      ↳ PiDP

                        ↳ PiDPToQDPProof

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Rewriting

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Narrowing

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Narrowing

                                                      ↳ QDP

                                                        ↳ DependencyGraphProof

                                                          ↳ QDP

                                                            ↳ Narrowing

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Instantiation

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ DependencyGraphProof

                                                                                                  ↳ QDP

                                                                                                    ↳ Instantiation

                                                                                                      ↳ QDP

                                                                                                        ↳ DependencyGraphProof

                                                                                                          ↳ QDP

                                                                                                            ↳ Instantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ Narrowing

                                                                                                                  ↳ QDP

                                                                                                                    ↳ DependencyGraphProof

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

FIB_IN_GA(M) → U1_GA(M, =_out_ag(M))
U8_GA(U, M2, fib_out_ga(N1)) → FIB_IN_GA(M2)
U7_GA(U, M1, =_out_ag(M2)) → FIB_IN_GA(M1)
U2_GA(succ(x1), succ(x1), =_out_ag(succ(zero))) → U3_GA(succ(x1), U71_gg(isGreater_in_gg(x1, zero)))
U1_GA(z0, =_out_ag(z0)) → U2_GA(z0, z0, =_out_ag(succ(zero)))
U7_GA(y0, zero, =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(zero))
U5_GA(succ(pred(pred(x2))), pred(pred(x2)), =_out_ag(pred(pred(x2)))) → U6_GA(pred(pred(x2)), pred(pred(x2)), U44_ggg(U46_ggg(isMinus_in_ggg(pred(x2), zero, x2))))
U6_GA(U, M1, isMinus_out_ggg) → U7_GA(U, M1, =_out_ag(U))
U7_GA(y0, x0, =_out_ag(y2)) → U8_GA(y0, y2, U1_ga(x0, =_out_ag(x0)))
U5_GA(succ(succ(x0)), succ(x0), =_out_ag(succ(x0))) → U6_GA(succ(x0), succ(x0), U44_ggg(U44_ggg(isMinus_in_ggg(x0, zero, succ(x0)))))
U3_GA(succ(x0), isGreater_out_gg) → U4_GA(succ(x0), isMinus_out_gga(x0))
U7_GA(y0, succ(zero), =_out_ag(y2)) → U8_GA(y0, y2, fib_out_ga(succ(zero)))
U4_GA(succ(z0), isMinus_out_gga(z0)) → U5_GA(succ(z0), z0, =_out_ag(z0))

The TRS R consists of the following rules:

fib_in_ga(zero) → fib_out_ga(zero)
fib_in_ga(succ(zero)) → fib_out_ga(succ(zero))
fib_in_ga(M) → U1_ga(M, =_in_ag(M))
=_in_ag(X) → =_out_ag(X)
U1_ga(M, =_out_ag(X)) → U2_ga(M, X, =_in_ag(succ(zero)))
U2_ga(M, X, =_out_ag(X1)) → U3_ga(M, 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)) → U71_gg(isGreater_in_gg(X, Y))
isGreater_in_gg(zero, pred(Y)) → isGreater_out_gg
isGreater_in_gg(pred(X), pred(Y)) → U72_gg(isGreater_in_gg(X, Y))
U72_gg(isGreater_out_gg) → isGreater_out_gg
U71_gg(isGreater_out_gg) → isGreater_out_gg
U3_ga(M, isGreater_out_gg) → U4_ga(M, isMinus_in_gga(M, succ(zero)))
isMinus_in_gga(X, zero) → isMinus_out_gga(X)
isMinus_in_gga(zero, succ(Y)) → U42_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(zero, pred(Y)) → U43_gga(isMinus_in_gga(zero, Y))
isMinus_in_gga(succ(X), succ(Y)) → U44_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(succ(X), pred(Y)) → U45_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), succ(Y)) → U46_gga(isMinus_in_gga(X, Y))
isMinus_in_gga(pred(X), pred(Y)) → U47_gga(isMinus_in_gga(X, Y))
U47_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U46_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(pred(Z)))
U45_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(succ(Z)))
U44_gga(isMinus_out_gga(Z)) → isMinus_out_gga(Z)
U43_gga(isMinus_out_gga(Z)) → isMinus_out_gga(succ(Z))
U42_gga(isMinus_out_gga(Z)) → isMinus_out_gga(pred(Z))
U4_ga(M, isMinus_out_gga(U)) → U5_ga(M, U, =_in_ag(U))
U5_ga(M, U, =_out_ag(M1)) → U6_ga(U, M1, isMinus_in_ggg(M, succ(succ(zero)), U))
isMinus_in_ggg(X, zero, X) → isMinus_out_ggg
isMinus_in_ggg(zero, succ(Y), pred(Z)) → U42_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(zero, pred(Y), succ(Z)) → U43_ggg(isMinus_in_ggg(zero, Y, Z))
isMinus_in_ggg(succ(X), succ(Y), Z) → U44_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) → U45_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) → U46_ggg(isMinus_in_ggg(X, Y, Z))
isMinus_in_ggg(pred(X), pred(Y), Z) → U47_ggg(isMinus_in_ggg(X, Y, Z))
U47_ggg(isMinus_out_ggg) → isMinus_out_ggg
U46_ggg(isMinus_out_ggg) → isMinus_out_ggg
U45_ggg(isMinus_out_ggg) → isMinus_out_ggg
U44_ggg(isMinus_out_ggg) → isMinus_out_ggg
U43_ggg(isMinus_out_ggg) → isMinus_out_ggg
U42_ggg(isMinus_out_ggg) → isMinus_out_ggg
U6_ga(U, M1, isMinus_out_ggg) → U7_ga(U, M1, =_in_ag(U))
U7_ga(U, M1, =_out_ag(M2)) → U8_ga(U, M2, fib_in_ga(M1))
U8_ga(U, M2, fib_out_ga(N1)) → U9_ga(U, N1, fib_in_ga(M2))
U9_ga(U, N1, fib_out_ga(N2)) → U10_ga(U, isPlus_in_ggg(N1, N2, U))
isPlus_in_ggg(zero, X, X) → isPlus_out_ggg
isPlus_in_ggg(succ(X), zero, succ(X)) → isPlus_out_ggg
isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) → U38_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(succ(X), pred(Y), Z) → U39_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), zero, pred(X)) → isPlus_out_ggg
isPlus_in_ggg(pred(X), succ(Y), Z) → U40_ggg(isPlus_in_ggg(X, Y, Z))
isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) → U41_ggg(isPlus_in_ggg(X, Y, Z))
U41_ggg(isPlus_out_ggg) → isPlus_out_ggg
U40_ggg(isPlus_out_ggg) → isPlus_out_ggg
U39_ggg(isPlus_out_ggg) → isPlus_out_ggg
U38_ggg(isPlus_out_ggg) → isPlus_out_ggg
U10_ga(U, isPlus_out_ggg) → U11_ga(=_in_ag(U))
U11_ga(=_out_ag(N)) → fib_out_ga(N)

The set Q consists of the following terms:

fib_in_ga(x0)
=_in_ag(x0)
U1_ga(x0, x1)
U2_ga(x0, x1, x2)
isGreater_in_gg(x0, x1)
U72_gg(x0)
U71_gg(x0)
U3_ga(x0, x1)
isMinus_in_gga(x0, x1)
U47_gga(x0)
U46_gga(x0)
U45_gga(x0)
U44_gga(x0)
U43_gga(x0)
U42_gga(x0)
U4_ga(x0, x1)
U5_ga(x0, x1, x2)
isMinus_in_ggg(x0, x1, x2)
U47_ggg(x0)
U46_ggg(x0)
U45_ggg(x0)
U44_ggg(x0)
U43_ggg(x0)
U42_ggg(x0)
U6_ga(x0, x1, x2)
U7_ga(x0, x1, x2)
U8_ga(x0, x1, x2)
U9_ga(x0, x1, x2)
isPlus_in_ggg(x0, x1, x2)
U41_ggg(x0)
U40_ggg(x0)
U39_ggg(x0)
U38_ggg(x0)
U10_ga(x0, x1)
U11_ga(x0)

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