(0) Obligation:

Clauses:

minus(X, Y, Z) :- ','(=(X, 0), ','(!, =(Z, 0))).
minus(X, Y, Z) :- ','(=(Y, 0), ','(!, =(Z, X))).
minus(X, Y, Z) :- ','(=(X, s(A)), ','(=(Y, s(B)), minus(A, B, Z))).
div(X, Y, Z) :- ','(=(Y, 0), ','(!, fail)).
div(X, Y, Z) :- ','(=(X, 0), ','(!, =(Z, 0))).
div(X, Y, Z) :- ','(minus(X, Y, U), ','(div(U, Y, V), =(Z, s(V)))).
=(X, X).

Queries:

div(g,g,a).

(1) PredefinedPredicateTransformerProof (SOUND transformation)

Added definitions of predefined predicates [PROLOG].

(2) Obligation:

Clauses:

minus(X, Y, Z) :- ','(=1(X, 0), ','(!, =1(Z, 0))).
minus(X, Y, Z) :- ','(=1(Y, 0), ','(!, =1(Z, X))).
minus(X, Y, Z) :- ','(=1(X, s(A)), ','(=1(Y, s(B)), minus(A, B, Z))).
div(X, Y, Z) :- ','(=1(Y, 0), ','(!, fail)).
div(X, Y, Z) :- ','(=1(X, 0), ','(!, =1(Z, 0))).
div(X, Y, Z) :- ','(minus(X, Y, U), ','(div(U, Y, V), =1(Z, s(V)))).
=1(X, X).
fail :- fail(b).
fail(a).

Queries:

div(g,g,a).

(3) PrologToPrologProblemTransformerProof (SOUND transformation)

Built Prolog problem from termination graph.

(4) Obligation:

Clauses:

minus33(0, T30, 0).
minus33(T35, 0, T35).
minus33(s(T39), s(T41), X90) :- minus33(T39, T41, X90).
minus19(s(0), s(T30), 0).
minus19(s(T35), s(0), T35).
minus19(s(s(T39)), s(s(T41)), X90) :- minus33(T39, T41, X90).
div59(0, T46, 0).
div59(T48, T49, X124) :- minus19(T48, T49, X122).
div59(T48, T49, X124) :- ','(minus19(T48, T49, T50), div59(T50, T49, X123)).
div59(T48, T49, s(T52)) :- ','(minus19(T48, T49, T50), div59(T50, T49, T52)).
div1(0, T9, 0).
div1(T14, T15, T17) :- minus19(T14, T15, X25).
div1(T14, T15, T17) :- ','(minus19(T14, T15, T18), div59(T18, T15, X26)).
div1(T14, T15, s(T54)) :- ','(minus19(T14, T15, T18), div59(T18, T15, T54)).

Queries:

div1(g,g,a).

(5) PrologToPiTRSProof (SOUND transformation)

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

div1_in_gga(0, T9, 0) → div1_out_gga(0, T9, 0)
div1_in_gga(T14, T15, T17) → U8_gga(T14, T15, T17, minus19_in_gga(T14, T15, X25))
minus19_in_gga(s(0), s(T30), 0) → minus19_out_gga(s(0), s(T30), 0)
minus19_in_gga(s(T35), s(0), T35) → minus19_out_gga(s(T35), s(0), T35)
minus19_in_gga(s(s(T39)), s(s(T41)), X90) → U2_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
minus33_in_gga(0, T30, 0) → minus33_out_gga(0, T30, 0)
minus33_in_gga(T35, 0, T35) → minus33_out_gga(T35, 0, T35)
minus33_in_gga(s(T39), s(T41), X90) → U1_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
U1_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus33_out_gga(s(T39), s(T41), X90)
U2_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus19_out_gga(s(s(T39)), s(s(T41)), X90)
U8_gga(T14, T15, T17, minus19_out_gga(T14, T15, X25)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, T17) → U9_gga(T14, T15, T17, minus19_in_gga(T14, T15, T18))
U9_gga(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → U10_gga(T14, T15, T17, div59_in_gga(T18, T15, X26))
div59_in_gga(0, T46, 0) → div59_out_gga(0, T46, 0)
div59_in_gga(T48, T49, X124) → U3_gga(T48, T49, X124, minus19_in_gga(T48, T49, X122))
U3_gga(T48, T49, X124, minus19_out_gga(T48, T49, X122)) → div59_out_gga(T48, T49, X124)
div59_in_gga(T48, T49, X124) → U4_gga(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_gga(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → U5_gga(T48, T49, X124, div59_in_gga(T50, T49, X123))
div59_in_gga(T48, T49, s(T52)) → U6_gga(T48, T49, T52, minus19_in_gga(T48, T49, T50))
U6_gga(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → U7_gga(T48, T49, T52, div59_in_gga(T50, T49, T52))
U7_gga(T48, T49, T52, div59_out_gga(T50, T49, T52)) → div59_out_gga(T48, T49, s(T52))
U5_gga(T48, T49, X124, div59_out_gga(T50, T49, X123)) → div59_out_gga(T48, T49, X124)
U10_gga(T14, T15, T17, div59_out_gga(T18, T15, X26)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, s(T54)) → U11_gga(T14, T15, T54, minus19_in_gga(T14, T15, T18))
U11_gga(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → U12_gga(T14, T15, T54, div59_in_gga(T18, T15, T54))
U12_gga(T14, T15, T54, div59_out_gga(T18, T15, T54)) → div1_out_gga(T14, T15, s(T54))

The argument filtering Pi contains the following mapping:
div1_in_gga(x1, x2, x3)  =  div1_in_gga(x1, x2)
0  =  0
div1_out_gga(x1, x2, x3)  =  div1_out_gga
U8_gga(x1, x2, x3, x4)  =  U8_gga(x4)
minus19_in_gga(x1, x2, x3)  =  minus19_in_gga(x1, x2)
s(x1)  =  s(x1)
minus19_out_gga(x1, x2, x3)  =  minus19_out_gga(x3)
U2_gga(x1, x2, x3, x4)  =  U2_gga(x4)
minus33_in_gga(x1, x2, x3)  =  minus33_in_gga(x1, x2)
minus33_out_gga(x1, x2, x3)  =  minus33_out_gga(x3)
U1_gga(x1, x2, x3, x4)  =  U1_gga(x4)
U9_gga(x1, x2, x3, x4)  =  U9_gga(x2, x4)
U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)
div59_in_gga(x1, x2, x3)  =  div59_in_gga(x1, x2)
div59_out_gga(x1, x2, x3)  =  div59_out_gga
U3_gga(x1, x2, x3, x4)  =  U3_gga(x4)
U4_gga(x1, x2, x3, x4)  =  U4_gga(x2, x4)
U5_gga(x1, x2, x3, x4)  =  U5_gga(x4)
U6_gga(x1, x2, x3, x4)  =  U6_gga(x2, x4)
U7_gga(x1, x2, x3, x4)  =  U7_gga(x4)
U11_gga(x1, x2, x3, x4)  =  U11_gga(x2, x4)
U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog

(6) Obligation:

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

div1_in_gga(0, T9, 0) → div1_out_gga(0, T9, 0)
div1_in_gga(T14, T15, T17) → U8_gga(T14, T15, T17, minus19_in_gga(T14, T15, X25))
minus19_in_gga(s(0), s(T30), 0) → minus19_out_gga(s(0), s(T30), 0)
minus19_in_gga(s(T35), s(0), T35) → minus19_out_gga(s(T35), s(0), T35)
minus19_in_gga(s(s(T39)), s(s(T41)), X90) → U2_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
minus33_in_gga(0, T30, 0) → minus33_out_gga(0, T30, 0)
minus33_in_gga(T35, 0, T35) → minus33_out_gga(T35, 0, T35)
minus33_in_gga(s(T39), s(T41), X90) → U1_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
U1_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus33_out_gga(s(T39), s(T41), X90)
U2_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus19_out_gga(s(s(T39)), s(s(T41)), X90)
U8_gga(T14, T15, T17, minus19_out_gga(T14, T15, X25)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, T17) → U9_gga(T14, T15, T17, minus19_in_gga(T14, T15, T18))
U9_gga(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → U10_gga(T14, T15, T17, div59_in_gga(T18, T15, X26))
div59_in_gga(0, T46, 0) → div59_out_gga(0, T46, 0)
div59_in_gga(T48, T49, X124) → U3_gga(T48, T49, X124, minus19_in_gga(T48, T49, X122))
U3_gga(T48, T49, X124, minus19_out_gga(T48, T49, X122)) → div59_out_gga(T48, T49, X124)
div59_in_gga(T48, T49, X124) → U4_gga(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_gga(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → U5_gga(T48, T49, X124, div59_in_gga(T50, T49, X123))
div59_in_gga(T48, T49, s(T52)) → U6_gga(T48, T49, T52, minus19_in_gga(T48, T49, T50))
U6_gga(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → U7_gga(T48, T49, T52, div59_in_gga(T50, T49, T52))
U7_gga(T48, T49, T52, div59_out_gga(T50, T49, T52)) → div59_out_gga(T48, T49, s(T52))
U5_gga(T48, T49, X124, div59_out_gga(T50, T49, X123)) → div59_out_gga(T48, T49, X124)
U10_gga(T14, T15, T17, div59_out_gga(T18, T15, X26)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, s(T54)) → U11_gga(T14, T15, T54, minus19_in_gga(T14, T15, T18))
U11_gga(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → U12_gga(T14, T15, T54, div59_in_gga(T18, T15, T54))
U12_gga(T14, T15, T54, div59_out_gga(T18, T15, T54)) → div1_out_gga(T14, T15, s(T54))

The argument filtering Pi contains the following mapping:
div1_in_gga(x1, x2, x3)  =  div1_in_gga(x1, x2)
0  =  0
div1_out_gga(x1, x2, x3)  =  div1_out_gga
U8_gga(x1, x2, x3, x4)  =  U8_gga(x4)
minus19_in_gga(x1, x2, x3)  =  minus19_in_gga(x1, x2)
s(x1)  =  s(x1)
minus19_out_gga(x1, x2, x3)  =  minus19_out_gga(x3)
U2_gga(x1, x2, x3, x4)  =  U2_gga(x4)
minus33_in_gga(x1, x2, x3)  =  minus33_in_gga(x1, x2)
minus33_out_gga(x1, x2, x3)  =  minus33_out_gga(x3)
U1_gga(x1, x2, x3, x4)  =  U1_gga(x4)
U9_gga(x1, x2, x3, x4)  =  U9_gga(x2, x4)
U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)
div59_in_gga(x1, x2, x3)  =  div59_in_gga(x1, x2)
div59_out_gga(x1, x2, x3)  =  div59_out_gga
U3_gga(x1, x2, x3, x4)  =  U3_gga(x4)
U4_gga(x1, x2, x3, x4)  =  U4_gga(x2, x4)
U5_gga(x1, x2, x3, x4)  =  U5_gga(x4)
U6_gga(x1, x2, x3, x4)  =  U6_gga(x2, x4)
U7_gga(x1, x2, x3, x4)  =  U7_gga(x4)
U11_gga(x1, x2, x3, x4)  =  U11_gga(x2, x4)
U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

(7) DependencyPairsProof (EQUIVALENT transformation)

Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

DIV1_IN_GGA(T14, T15, T17) → U8_GGA(T14, T15, T17, minus19_in_gga(T14, T15, X25))
DIV1_IN_GGA(T14, T15, T17) → MINUS19_IN_GGA(T14, T15, X25)
MINUS19_IN_GGA(s(s(T39)), s(s(T41)), X90) → U2_GGA(T39, T41, X90, minus33_in_gga(T39, T41, X90))
MINUS19_IN_GGA(s(s(T39)), s(s(T41)), X90) → MINUS33_IN_GGA(T39, T41, X90)
MINUS33_IN_GGA(s(T39), s(T41), X90) → U1_GGA(T39, T41, X90, minus33_in_gga(T39, T41, X90))
MINUS33_IN_GGA(s(T39), s(T41), X90) → MINUS33_IN_GGA(T39, T41, X90)
DIV1_IN_GGA(T14, T15, T17) → U9_GGA(T14, T15, T17, minus19_in_gga(T14, T15, T18))
U9_GGA(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → U10_GGA(T14, T15, T17, div59_in_gga(T18, T15, X26))
U9_GGA(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → DIV59_IN_GGA(T18, T15, X26)
DIV59_IN_GGA(T48, T49, X124) → U3_GGA(T48, T49, X124, minus19_in_gga(T48, T49, X122))
DIV59_IN_GGA(T48, T49, X124) → MINUS19_IN_GGA(T48, T49, X122)
DIV59_IN_GGA(T48, T49, X124) → U4_GGA(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_GGA(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → U5_GGA(T48, T49, X124, div59_in_gga(T50, T49, X123))
U4_GGA(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → DIV59_IN_GGA(T50, T49, X123)
DIV59_IN_GGA(T48, T49, s(T52)) → U6_GGA(T48, T49, T52, minus19_in_gga(T48, T49, T50))
DIV59_IN_GGA(T48, T49, s(T52)) → MINUS19_IN_GGA(T48, T49, T50)
U6_GGA(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → U7_GGA(T48, T49, T52, div59_in_gga(T50, T49, T52))
U6_GGA(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → DIV59_IN_GGA(T50, T49, T52)
DIV1_IN_GGA(T14, T15, s(T54)) → U11_GGA(T14, T15, T54, minus19_in_gga(T14, T15, T18))
DIV1_IN_GGA(T14, T15, s(T54)) → MINUS19_IN_GGA(T14, T15, T18)
U11_GGA(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → U12_GGA(T14, T15, T54, div59_in_gga(T18, T15, T54))
U11_GGA(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → DIV59_IN_GGA(T18, T15, T54)

The TRS R consists of the following rules:

div1_in_gga(0, T9, 0) → div1_out_gga(0, T9, 0)
div1_in_gga(T14, T15, T17) → U8_gga(T14, T15, T17, minus19_in_gga(T14, T15, X25))
minus19_in_gga(s(0), s(T30), 0) → minus19_out_gga(s(0), s(T30), 0)
minus19_in_gga(s(T35), s(0), T35) → minus19_out_gga(s(T35), s(0), T35)
minus19_in_gga(s(s(T39)), s(s(T41)), X90) → U2_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
minus33_in_gga(0, T30, 0) → minus33_out_gga(0, T30, 0)
minus33_in_gga(T35, 0, T35) → minus33_out_gga(T35, 0, T35)
minus33_in_gga(s(T39), s(T41), X90) → U1_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
U1_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus33_out_gga(s(T39), s(T41), X90)
U2_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus19_out_gga(s(s(T39)), s(s(T41)), X90)
U8_gga(T14, T15, T17, minus19_out_gga(T14, T15, X25)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, T17) → U9_gga(T14, T15, T17, minus19_in_gga(T14, T15, T18))
U9_gga(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → U10_gga(T14, T15, T17, div59_in_gga(T18, T15, X26))
div59_in_gga(0, T46, 0) → div59_out_gga(0, T46, 0)
div59_in_gga(T48, T49, X124) → U3_gga(T48, T49, X124, minus19_in_gga(T48, T49, X122))
U3_gga(T48, T49, X124, minus19_out_gga(T48, T49, X122)) → div59_out_gga(T48, T49, X124)
div59_in_gga(T48, T49, X124) → U4_gga(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_gga(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → U5_gga(T48, T49, X124, div59_in_gga(T50, T49, X123))
div59_in_gga(T48, T49, s(T52)) → U6_gga(T48, T49, T52, minus19_in_gga(T48, T49, T50))
U6_gga(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → U7_gga(T48, T49, T52, div59_in_gga(T50, T49, T52))
U7_gga(T48, T49, T52, div59_out_gga(T50, T49, T52)) → div59_out_gga(T48, T49, s(T52))
U5_gga(T48, T49, X124, div59_out_gga(T50, T49, X123)) → div59_out_gga(T48, T49, X124)
U10_gga(T14, T15, T17, div59_out_gga(T18, T15, X26)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, s(T54)) → U11_gga(T14, T15, T54, minus19_in_gga(T14, T15, T18))
U11_gga(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → U12_gga(T14, T15, T54, div59_in_gga(T18, T15, T54))
U12_gga(T14, T15, T54, div59_out_gga(T18, T15, T54)) → div1_out_gga(T14, T15, s(T54))

The argument filtering Pi contains the following mapping:
div1_in_gga(x1, x2, x3)  =  div1_in_gga(x1, x2)
0  =  0
div1_out_gga(x1, x2, x3)  =  div1_out_gga
U8_gga(x1, x2, x3, x4)  =  U8_gga(x4)
minus19_in_gga(x1, x2, x3)  =  minus19_in_gga(x1, x2)
s(x1)  =  s(x1)
minus19_out_gga(x1, x2, x3)  =  minus19_out_gga(x3)
U2_gga(x1, x2, x3, x4)  =  U2_gga(x4)
minus33_in_gga(x1, x2, x3)  =  minus33_in_gga(x1, x2)
minus33_out_gga(x1, x2, x3)  =  minus33_out_gga(x3)
U1_gga(x1, x2, x3, x4)  =  U1_gga(x4)
U9_gga(x1, x2, x3, x4)  =  U9_gga(x2, x4)
U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)
div59_in_gga(x1, x2, x3)  =  div59_in_gga(x1, x2)
div59_out_gga(x1, x2, x3)  =  div59_out_gga
U3_gga(x1, x2, x3, x4)  =  U3_gga(x4)
U4_gga(x1, x2, x3, x4)  =  U4_gga(x2, x4)
U5_gga(x1, x2, x3, x4)  =  U5_gga(x4)
U6_gga(x1, x2, x3, x4)  =  U6_gga(x2, x4)
U7_gga(x1, x2, x3, x4)  =  U7_gga(x4)
U11_gga(x1, x2, x3, x4)  =  U11_gga(x2, x4)
U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)
DIV1_IN_GGA(x1, x2, x3)  =  DIV1_IN_GGA(x1, x2)
U8_GGA(x1, x2, x3, x4)  =  U8_GGA(x4)
MINUS19_IN_GGA(x1, x2, x3)  =  MINUS19_IN_GGA(x1, x2)
U2_GGA(x1, x2, x3, x4)  =  U2_GGA(x4)
MINUS33_IN_GGA(x1, x2, x3)  =  MINUS33_IN_GGA(x1, x2)
U1_GGA(x1, x2, x3, x4)  =  U1_GGA(x4)
U9_GGA(x1, x2, x3, x4)  =  U9_GGA(x2, x4)
U10_GGA(x1, x2, x3, x4)  =  U10_GGA(x4)
DIV59_IN_GGA(x1, x2, x3)  =  DIV59_IN_GGA(x1, x2)
U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x4)
U4_GGA(x1, x2, x3, x4)  =  U4_GGA(x2, x4)
U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x4)
U6_GGA(x1, x2, x3, x4)  =  U6_GGA(x2, x4)
U7_GGA(x1, x2, x3, x4)  =  U7_GGA(x4)
U11_GGA(x1, x2, x3, x4)  =  U11_GGA(x2, x4)
U12_GGA(x1, x2, x3, x4)  =  U12_GGA(x4)

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

(8) Obligation:

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

DIV1_IN_GGA(T14, T15, T17) → U8_GGA(T14, T15, T17, minus19_in_gga(T14, T15, X25))
DIV1_IN_GGA(T14, T15, T17) → MINUS19_IN_GGA(T14, T15, X25)
MINUS19_IN_GGA(s(s(T39)), s(s(T41)), X90) → U2_GGA(T39, T41, X90, minus33_in_gga(T39, T41, X90))
MINUS19_IN_GGA(s(s(T39)), s(s(T41)), X90) → MINUS33_IN_GGA(T39, T41, X90)
MINUS33_IN_GGA(s(T39), s(T41), X90) → U1_GGA(T39, T41, X90, minus33_in_gga(T39, T41, X90))
MINUS33_IN_GGA(s(T39), s(T41), X90) → MINUS33_IN_GGA(T39, T41, X90)
DIV1_IN_GGA(T14, T15, T17) → U9_GGA(T14, T15, T17, minus19_in_gga(T14, T15, T18))
U9_GGA(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → U10_GGA(T14, T15, T17, div59_in_gga(T18, T15, X26))
U9_GGA(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → DIV59_IN_GGA(T18, T15, X26)
DIV59_IN_GGA(T48, T49, X124) → U3_GGA(T48, T49, X124, minus19_in_gga(T48, T49, X122))
DIV59_IN_GGA(T48, T49, X124) → MINUS19_IN_GGA(T48, T49, X122)
DIV59_IN_GGA(T48, T49, X124) → U4_GGA(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_GGA(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → U5_GGA(T48, T49, X124, div59_in_gga(T50, T49, X123))
U4_GGA(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → DIV59_IN_GGA(T50, T49, X123)
DIV59_IN_GGA(T48, T49, s(T52)) → U6_GGA(T48, T49, T52, minus19_in_gga(T48, T49, T50))
DIV59_IN_GGA(T48, T49, s(T52)) → MINUS19_IN_GGA(T48, T49, T50)
U6_GGA(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → U7_GGA(T48, T49, T52, div59_in_gga(T50, T49, T52))
U6_GGA(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → DIV59_IN_GGA(T50, T49, T52)
DIV1_IN_GGA(T14, T15, s(T54)) → U11_GGA(T14, T15, T54, minus19_in_gga(T14, T15, T18))
DIV1_IN_GGA(T14, T15, s(T54)) → MINUS19_IN_GGA(T14, T15, T18)
U11_GGA(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → U12_GGA(T14, T15, T54, div59_in_gga(T18, T15, T54))
U11_GGA(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → DIV59_IN_GGA(T18, T15, T54)

The TRS R consists of the following rules:

div1_in_gga(0, T9, 0) → div1_out_gga(0, T9, 0)
div1_in_gga(T14, T15, T17) → U8_gga(T14, T15, T17, minus19_in_gga(T14, T15, X25))
minus19_in_gga(s(0), s(T30), 0) → minus19_out_gga(s(0), s(T30), 0)
minus19_in_gga(s(T35), s(0), T35) → minus19_out_gga(s(T35), s(0), T35)
minus19_in_gga(s(s(T39)), s(s(T41)), X90) → U2_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
minus33_in_gga(0, T30, 0) → minus33_out_gga(0, T30, 0)
minus33_in_gga(T35, 0, T35) → minus33_out_gga(T35, 0, T35)
minus33_in_gga(s(T39), s(T41), X90) → U1_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
U1_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus33_out_gga(s(T39), s(T41), X90)
U2_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus19_out_gga(s(s(T39)), s(s(T41)), X90)
U8_gga(T14, T15, T17, minus19_out_gga(T14, T15, X25)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, T17) → U9_gga(T14, T15, T17, minus19_in_gga(T14, T15, T18))
U9_gga(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → U10_gga(T14, T15, T17, div59_in_gga(T18, T15, X26))
div59_in_gga(0, T46, 0) → div59_out_gga(0, T46, 0)
div59_in_gga(T48, T49, X124) → U3_gga(T48, T49, X124, minus19_in_gga(T48, T49, X122))
U3_gga(T48, T49, X124, minus19_out_gga(T48, T49, X122)) → div59_out_gga(T48, T49, X124)
div59_in_gga(T48, T49, X124) → U4_gga(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_gga(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → U5_gga(T48, T49, X124, div59_in_gga(T50, T49, X123))
div59_in_gga(T48, T49, s(T52)) → U6_gga(T48, T49, T52, minus19_in_gga(T48, T49, T50))
U6_gga(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → U7_gga(T48, T49, T52, div59_in_gga(T50, T49, T52))
U7_gga(T48, T49, T52, div59_out_gga(T50, T49, T52)) → div59_out_gga(T48, T49, s(T52))
U5_gga(T48, T49, X124, div59_out_gga(T50, T49, X123)) → div59_out_gga(T48, T49, X124)
U10_gga(T14, T15, T17, div59_out_gga(T18, T15, X26)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, s(T54)) → U11_gga(T14, T15, T54, minus19_in_gga(T14, T15, T18))
U11_gga(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → U12_gga(T14, T15, T54, div59_in_gga(T18, T15, T54))
U12_gga(T14, T15, T54, div59_out_gga(T18, T15, T54)) → div1_out_gga(T14, T15, s(T54))

The argument filtering Pi contains the following mapping:
div1_in_gga(x1, x2, x3)  =  div1_in_gga(x1, x2)
0  =  0
div1_out_gga(x1, x2, x3)  =  div1_out_gga
U8_gga(x1, x2, x3, x4)  =  U8_gga(x4)
minus19_in_gga(x1, x2, x3)  =  minus19_in_gga(x1, x2)
s(x1)  =  s(x1)
minus19_out_gga(x1, x2, x3)  =  minus19_out_gga(x3)
U2_gga(x1, x2, x3, x4)  =  U2_gga(x4)
minus33_in_gga(x1, x2, x3)  =  minus33_in_gga(x1, x2)
minus33_out_gga(x1, x2, x3)  =  minus33_out_gga(x3)
U1_gga(x1, x2, x3, x4)  =  U1_gga(x4)
U9_gga(x1, x2, x3, x4)  =  U9_gga(x2, x4)
U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)
div59_in_gga(x1, x2, x3)  =  div59_in_gga(x1, x2)
div59_out_gga(x1, x2, x3)  =  div59_out_gga
U3_gga(x1, x2, x3, x4)  =  U3_gga(x4)
U4_gga(x1, x2, x3, x4)  =  U4_gga(x2, x4)
U5_gga(x1, x2, x3, x4)  =  U5_gga(x4)
U6_gga(x1, x2, x3, x4)  =  U6_gga(x2, x4)
U7_gga(x1, x2, x3, x4)  =  U7_gga(x4)
U11_gga(x1, x2, x3, x4)  =  U11_gga(x2, x4)
U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)
DIV1_IN_GGA(x1, x2, x3)  =  DIV1_IN_GGA(x1, x2)
U8_GGA(x1, x2, x3, x4)  =  U8_GGA(x4)
MINUS19_IN_GGA(x1, x2, x3)  =  MINUS19_IN_GGA(x1, x2)
U2_GGA(x1, x2, x3, x4)  =  U2_GGA(x4)
MINUS33_IN_GGA(x1, x2, x3)  =  MINUS33_IN_GGA(x1, x2)
U1_GGA(x1, x2, x3, x4)  =  U1_GGA(x4)
U9_GGA(x1, x2, x3, x4)  =  U9_GGA(x2, x4)
U10_GGA(x1, x2, x3, x4)  =  U10_GGA(x4)
DIV59_IN_GGA(x1, x2, x3)  =  DIV59_IN_GGA(x1, x2)
U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x4)
U4_GGA(x1, x2, x3, x4)  =  U4_GGA(x2, x4)
U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x4)
U6_GGA(x1, x2, x3, x4)  =  U6_GGA(x2, x4)
U7_GGA(x1, x2, x3, x4)  =  U7_GGA(x4)
U11_GGA(x1, x2, x3, x4)  =  U11_GGA(x2, x4)
U12_GGA(x1, x2, x3, x4)  =  U12_GGA(x4)

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

(9) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LOPSTR] contains 2 SCCs with 17 less nodes.

(10) Complex Obligation (AND)

(11) Obligation:

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

MINUS33_IN_GGA(s(T39), s(T41), X90) → MINUS33_IN_GGA(T39, T41, X90)

The TRS R consists of the following rules:

div1_in_gga(0, T9, 0) → div1_out_gga(0, T9, 0)
div1_in_gga(T14, T15, T17) → U8_gga(T14, T15, T17, minus19_in_gga(T14, T15, X25))
minus19_in_gga(s(0), s(T30), 0) → minus19_out_gga(s(0), s(T30), 0)
minus19_in_gga(s(T35), s(0), T35) → minus19_out_gga(s(T35), s(0), T35)
minus19_in_gga(s(s(T39)), s(s(T41)), X90) → U2_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
minus33_in_gga(0, T30, 0) → minus33_out_gga(0, T30, 0)
minus33_in_gga(T35, 0, T35) → minus33_out_gga(T35, 0, T35)
minus33_in_gga(s(T39), s(T41), X90) → U1_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
U1_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus33_out_gga(s(T39), s(T41), X90)
U2_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus19_out_gga(s(s(T39)), s(s(T41)), X90)
U8_gga(T14, T15, T17, minus19_out_gga(T14, T15, X25)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, T17) → U9_gga(T14, T15, T17, minus19_in_gga(T14, T15, T18))
U9_gga(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → U10_gga(T14, T15, T17, div59_in_gga(T18, T15, X26))
div59_in_gga(0, T46, 0) → div59_out_gga(0, T46, 0)
div59_in_gga(T48, T49, X124) → U3_gga(T48, T49, X124, minus19_in_gga(T48, T49, X122))
U3_gga(T48, T49, X124, minus19_out_gga(T48, T49, X122)) → div59_out_gga(T48, T49, X124)
div59_in_gga(T48, T49, X124) → U4_gga(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_gga(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → U5_gga(T48, T49, X124, div59_in_gga(T50, T49, X123))
div59_in_gga(T48, T49, s(T52)) → U6_gga(T48, T49, T52, minus19_in_gga(T48, T49, T50))
U6_gga(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → U7_gga(T48, T49, T52, div59_in_gga(T50, T49, T52))
U7_gga(T48, T49, T52, div59_out_gga(T50, T49, T52)) → div59_out_gga(T48, T49, s(T52))
U5_gga(T48, T49, X124, div59_out_gga(T50, T49, X123)) → div59_out_gga(T48, T49, X124)
U10_gga(T14, T15, T17, div59_out_gga(T18, T15, X26)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, s(T54)) → U11_gga(T14, T15, T54, minus19_in_gga(T14, T15, T18))
U11_gga(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → U12_gga(T14, T15, T54, div59_in_gga(T18, T15, T54))
U12_gga(T14, T15, T54, div59_out_gga(T18, T15, T54)) → div1_out_gga(T14, T15, s(T54))

The argument filtering Pi contains the following mapping:
div1_in_gga(x1, x2, x3)  =  div1_in_gga(x1, x2)
0  =  0
div1_out_gga(x1, x2, x3)  =  div1_out_gga
U8_gga(x1, x2, x3, x4)  =  U8_gga(x4)
minus19_in_gga(x1, x2, x3)  =  minus19_in_gga(x1, x2)
s(x1)  =  s(x1)
minus19_out_gga(x1, x2, x3)  =  minus19_out_gga(x3)
U2_gga(x1, x2, x3, x4)  =  U2_gga(x4)
minus33_in_gga(x1, x2, x3)  =  minus33_in_gga(x1, x2)
minus33_out_gga(x1, x2, x3)  =  minus33_out_gga(x3)
U1_gga(x1, x2, x3, x4)  =  U1_gga(x4)
U9_gga(x1, x2, x3, x4)  =  U9_gga(x2, x4)
U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)
div59_in_gga(x1, x2, x3)  =  div59_in_gga(x1, x2)
div59_out_gga(x1, x2, x3)  =  div59_out_gga
U3_gga(x1, x2, x3, x4)  =  U3_gga(x4)
U4_gga(x1, x2, x3, x4)  =  U4_gga(x2, x4)
U5_gga(x1, x2, x3, x4)  =  U5_gga(x4)
U6_gga(x1, x2, x3, x4)  =  U6_gga(x2, x4)
U7_gga(x1, x2, x3, x4)  =  U7_gga(x4)
U11_gga(x1, x2, x3, x4)  =  U11_gga(x2, x4)
U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)
MINUS33_IN_GGA(x1, x2, x3)  =  MINUS33_IN_GGA(x1, x2)

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

(12) UsableRulesProof (EQUIVALENT transformation)

For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.

(13) Obligation:

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

MINUS33_IN_GGA(s(T39), s(T41), X90) → MINUS33_IN_GGA(T39, T41, X90)

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

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

(14) PiDPToQDPProof (SOUND transformation)

Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.

(15) Obligation:

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

MINUS33_IN_GGA(s(T39), s(T41)) → MINUS33_IN_GGA(T39, T41)

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

(16) QDPSizeChangeProof (EQUIVALENT transformation)

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

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

  • MINUS33_IN_GGA(s(T39), s(T41)) → MINUS33_IN_GGA(T39, T41)
    The graph contains the following edges 1 > 1, 2 > 2

(17) TRUE

(18) Obligation:

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

DIV59_IN_GGA(T48, T49, X124) → U4_GGA(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_GGA(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → DIV59_IN_GGA(T50, T49, X123)
DIV59_IN_GGA(T48, T49, s(T52)) → U6_GGA(T48, T49, T52, minus19_in_gga(T48, T49, T50))
U6_GGA(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → DIV59_IN_GGA(T50, T49, T52)

The TRS R consists of the following rules:

div1_in_gga(0, T9, 0) → div1_out_gga(0, T9, 0)
div1_in_gga(T14, T15, T17) → U8_gga(T14, T15, T17, minus19_in_gga(T14, T15, X25))
minus19_in_gga(s(0), s(T30), 0) → minus19_out_gga(s(0), s(T30), 0)
minus19_in_gga(s(T35), s(0), T35) → minus19_out_gga(s(T35), s(0), T35)
minus19_in_gga(s(s(T39)), s(s(T41)), X90) → U2_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
minus33_in_gga(0, T30, 0) → minus33_out_gga(0, T30, 0)
minus33_in_gga(T35, 0, T35) → minus33_out_gga(T35, 0, T35)
minus33_in_gga(s(T39), s(T41), X90) → U1_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
U1_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus33_out_gga(s(T39), s(T41), X90)
U2_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus19_out_gga(s(s(T39)), s(s(T41)), X90)
U8_gga(T14, T15, T17, minus19_out_gga(T14, T15, X25)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, T17) → U9_gga(T14, T15, T17, minus19_in_gga(T14, T15, T18))
U9_gga(T14, T15, T17, minus19_out_gga(T14, T15, T18)) → U10_gga(T14, T15, T17, div59_in_gga(T18, T15, X26))
div59_in_gga(0, T46, 0) → div59_out_gga(0, T46, 0)
div59_in_gga(T48, T49, X124) → U3_gga(T48, T49, X124, minus19_in_gga(T48, T49, X122))
U3_gga(T48, T49, X124, minus19_out_gga(T48, T49, X122)) → div59_out_gga(T48, T49, X124)
div59_in_gga(T48, T49, X124) → U4_gga(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_gga(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → U5_gga(T48, T49, X124, div59_in_gga(T50, T49, X123))
div59_in_gga(T48, T49, s(T52)) → U6_gga(T48, T49, T52, minus19_in_gga(T48, T49, T50))
U6_gga(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → U7_gga(T48, T49, T52, div59_in_gga(T50, T49, T52))
U7_gga(T48, T49, T52, div59_out_gga(T50, T49, T52)) → div59_out_gga(T48, T49, s(T52))
U5_gga(T48, T49, X124, div59_out_gga(T50, T49, X123)) → div59_out_gga(T48, T49, X124)
U10_gga(T14, T15, T17, div59_out_gga(T18, T15, X26)) → div1_out_gga(T14, T15, T17)
div1_in_gga(T14, T15, s(T54)) → U11_gga(T14, T15, T54, minus19_in_gga(T14, T15, T18))
U11_gga(T14, T15, T54, minus19_out_gga(T14, T15, T18)) → U12_gga(T14, T15, T54, div59_in_gga(T18, T15, T54))
U12_gga(T14, T15, T54, div59_out_gga(T18, T15, T54)) → div1_out_gga(T14, T15, s(T54))

The argument filtering Pi contains the following mapping:
div1_in_gga(x1, x2, x3)  =  div1_in_gga(x1, x2)
0  =  0
div1_out_gga(x1, x2, x3)  =  div1_out_gga
U8_gga(x1, x2, x3, x4)  =  U8_gga(x4)
minus19_in_gga(x1, x2, x3)  =  minus19_in_gga(x1, x2)
s(x1)  =  s(x1)
minus19_out_gga(x1, x2, x3)  =  minus19_out_gga(x3)
U2_gga(x1, x2, x3, x4)  =  U2_gga(x4)
minus33_in_gga(x1, x2, x3)  =  minus33_in_gga(x1, x2)
minus33_out_gga(x1, x2, x3)  =  minus33_out_gga(x3)
U1_gga(x1, x2, x3, x4)  =  U1_gga(x4)
U9_gga(x1, x2, x3, x4)  =  U9_gga(x2, x4)
U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)
div59_in_gga(x1, x2, x3)  =  div59_in_gga(x1, x2)
div59_out_gga(x1, x2, x3)  =  div59_out_gga
U3_gga(x1, x2, x3, x4)  =  U3_gga(x4)
U4_gga(x1, x2, x3, x4)  =  U4_gga(x2, x4)
U5_gga(x1, x2, x3, x4)  =  U5_gga(x4)
U6_gga(x1, x2, x3, x4)  =  U6_gga(x2, x4)
U7_gga(x1, x2, x3, x4)  =  U7_gga(x4)
U11_gga(x1, x2, x3, x4)  =  U11_gga(x2, x4)
U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)
DIV59_IN_GGA(x1, x2, x3)  =  DIV59_IN_GGA(x1, x2)
U4_GGA(x1, x2, x3, x4)  =  U4_GGA(x2, x4)
U6_GGA(x1, x2, x3, x4)  =  U6_GGA(x2, x4)

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

(19) UsableRulesProof (EQUIVALENT transformation)

For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.

(20) Obligation:

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

DIV59_IN_GGA(T48, T49, X124) → U4_GGA(T48, T49, X124, minus19_in_gga(T48, T49, T50))
U4_GGA(T48, T49, X124, minus19_out_gga(T48, T49, T50)) → DIV59_IN_GGA(T50, T49, X123)
DIV59_IN_GGA(T48, T49, s(T52)) → U6_GGA(T48, T49, T52, minus19_in_gga(T48, T49, T50))
U6_GGA(T48, T49, T52, minus19_out_gga(T48, T49, T50)) → DIV59_IN_GGA(T50, T49, T52)

The TRS R consists of the following rules:

minus19_in_gga(s(0), s(T30), 0) → minus19_out_gga(s(0), s(T30), 0)
minus19_in_gga(s(T35), s(0), T35) → minus19_out_gga(s(T35), s(0), T35)
minus19_in_gga(s(s(T39)), s(s(T41)), X90) → U2_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
U2_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus19_out_gga(s(s(T39)), s(s(T41)), X90)
minus33_in_gga(0, T30, 0) → minus33_out_gga(0, T30, 0)
minus33_in_gga(T35, 0, T35) → minus33_out_gga(T35, 0, T35)
minus33_in_gga(s(T39), s(T41), X90) → U1_gga(T39, T41, X90, minus33_in_gga(T39, T41, X90))
U1_gga(T39, T41, X90, minus33_out_gga(T39, T41, X90)) → minus33_out_gga(s(T39), s(T41), X90)

The argument filtering Pi contains the following mapping:
0  =  0
minus19_in_gga(x1, x2, x3)  =  minus19_in_gga(x1, x2)
s(x1)  =  s(x1)
minus19_out_gga(x1, x2, x3)  =  minus19_out_gga(x3)
U2_gga(x1, x2, x3, x4)  =  U2_gga(x4)
minus33_in_gga(x1, x2, x3)  =  minus33_in_gga(x1, x2)
minus33_out_gga(x1, x2, x3)  =  minus33_out_gga(x3)
U1_gga(x1, x2, x3, x4)  =  U1_gga(x4)
DIV59_IN_GGA(x1, x2, x3)  =  DIV59_IN_GGA(x1, x2)
U4_GGA(x1, x2, x3, x4)  =  U4_GGA(x2, x4)
U6_GGA(x1, x2, x3, x4)  =  U6_GGA(x2, x4)

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

(21) PiDPToQDPProof (SOUND transformation)

Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.

(22) Obligation:

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

DIV59_IN_GGA(T48, T49) → U4_GGA(T49, minus19_in_gga(T48, T49))
U4_GGA(T49, minus19_out_gga(T50)) → DIV59_IN_GGA(T50, T49)
DIV59_IN_GGA(T48, T49) → U6_GGA(T49, minus19_in_gga(T48, T49))
U6_GGA(T49, minus19_out_gga(T50)) → DIV59_IN_GGA(T50, T49)

The TRS R consists of the following rules:

minus19_in_gga(s(0), s(T30)) → minus19_out_gga(0)
minus19_in_gga(s(T35), s(0)) → minus19_out_gga(T35)
minus19_in_gga(s(s(T39)), s(s(T41))) → U2_gga(minus33_in_gga(T39, T41))
U2_gga(minus33_out_gga(X90)) → minus19_out_gga(X90)
minus33_in_gga(0, T30) → minus33_out_gga(0)
minus33_in_gga(T35, 0) → minus33_out_gga(T35)
minus33_in_gga(s(T39), s(T41)) → U1_gga(minus33_in_gga(T39, T41))
U1_gga(minus33_out_gga(X90)) → minus33_out_gga(X90)

The set Q consists of the following terms:

minus19_in_gga(x0, x1)
U2_gga(x0)
minus33_in_gga(x0, x1)
U1_gga(x0)

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

(23) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


U4_GGA(T49, minus19_out_gga(T50)) → DIV59_IN_GGA(T50, T49)
U6_GGA(T49, minus19_out_gga(T50)) → DIV59_IN_GGA(T50, T49)
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(DIV59_IN_GGA(x1, x2)) = x1   
POL(U1_gga(x1)) = 1 + x1   
POL(U2_gga(x1)) = 1 + x1   
POL(U4_GGA(x1, x2)) = x2   
POL(U6_GGA(x1, x2)) = x2   
POL(minus19_in_gga(x1, x2)) = x1   
POL(minus19_out_gga(x1)) = 1 + x1   
POL(minus33_in_gga(x1, x2)) = 1 + x1   
POL(minus33_out_gga(x1)) = x1   
POL(s(x1)) = 1 + x1   

The following usable rules [FROCOS05] were oriented:

minus19_in_gga(s(0), s(T30)) → minus19_out_gga(0)
minus19_in_gga(s(T35), s(0)) → minus19_out_gga(T35)
minus19_in_gga(s(s(T39)), s(s(T41))) → U2_gga(minus33_in_gga(T39, T41))
minus33_in_gga(0, T30) → minus33_out_gga(0)
minus33_in_gga(T35, 0) → minus33_out_gga(T35)
minus33_in_gga(s(T39), s(T41)) → U1_gga(minus33_in_gga(T39, T41))
U2_gga(minus33_out_gga(X90)) → minus19_out_gga(X90)
U1_gga(minus33_out_gga(X90)) → minus33_out_gga(X90)

(24) Obligation:

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

DIV59_IN_GGA(T48, T49) → U4_GGA(T49, minus19_in_gga(T48, T49))
DIV59_IN_GGA(T48, T49) → U6_GGA(T49, minus19_in_gga(T48, T49))

The TRS R consists of the following rules:

minus19_in_gga(s(0), s(T30)) → minus19_out_gga(0)
minus19_in_gga(s(T35), s(0)) → minus19_out_gga(T35)
minus19_in_gga(s(s(T39)), s(s(T41))) → U2_gga(minus33_in_gga(T39, T41))
U2_gga(minus33_out_gga(X90)) → minus19_out_gga(X90)
minus33_in_gga(0, T30) → minus33_out_gga(0)
minus33_in_gga(T35, 0) → minus33_out_gga(T35)
minus33_in_gga(s(T39), s(T41)) → U1_gga(minus33_in_gga(T39, T41))
U1_gga(minus33_out_gga(X90)) → minus33_out_gga(X90)

The set Q consists of the following terms:

minus19_in_gga(x0, x1)
U2_gga(x0)
minus33_in_gga(x0, x1)
U1_gga(x0)

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

(25) DependencyGraphProof (EQUIVALENT transformation)

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

(26) TRUE