Left Termination of the query pattern turing_in_4(g, g, g, a) w.r.t. the given Prolog program could not be shown:

0 Prolog
  ↳1 PrologToPiTRSProof (⇐)
    ↳2 PiTRS
    ↳3 DependencyPairsProof (⇔)
    ↳4 PiDP
    ↳5 DependencyGraphProof (⇔)
    ↳6 AND
      ↳7 PiDP
        ↳8 UsableRulesProof (⇔)
        ↳9 PiDP
        ↳10 PiDPToQDPProof (⇐)
        ↳11 QDP
        ↳12 QDPSizeChangeProof (⇔)
        ↳13 TRUE
      ↳14 PiDP
        ↳15 UsableRulesProof (⇔)
        ↳16 PiDP
        ↳17 PiDPToQDPProof (⇐)
        ↳18 QDP
          ↳19 Instantiation (⇔)
            ↳20 QDP
          ↳21 Narrowing (⇐)
            ↳22 QDP
            ↳23 Narrowing (⇐)
            ↳24 QDP
            ↳25 Narrowing (⇐)
            ↳26 QDP
            ↳27 Narrowing (⇐)
            ↳28 QDP
            ↳29 Instantiation (⇔)
            ↳30 QDP
            ↳31 Instantiation (⇔)
            ↳32 QDP
            ↳33 Instantiation (⇔)
            ↳34 QDP
            ↳35 Instantiation (⇔)
            ↳36 QDP
            ↳37 Instantiation (⇔)
            ↳38 QDP
            ↳39 Instantiation (⇔)
            ↳40 QDP
            ↳41 Instantiation (⇔)
            ↳42 QDP
            ↳43 Instantiation (⇔)
            ↳44 QDP
            ↳45 Instantiation (⇔)
            ↳46 QDP
            ↳47 Instantiation (⇔)
            ↳48 QDP
            ↳49 Instantiation (⇔)
            ↳50 QDP
            ↳51 Instantiation (⇔)
            ↳52 QDP
            ↳53 ForwardInstantiation (⇔)
            ↳54 QDP
            ↳55 ForwardInstantiation (⇔)
            ↳56 QDP
            ↳57 ForwardInstantiation (⇔)
            ↳58 QDP
            ↳59 ForwardInstantiation (⇔)
            ↳60 QDP
            ↳61 ForwardInstantiation (⇔)
            ↳62 QDP
            ↳63 ForwardInstantiation (⇔)
            ↳64 QDP
  ↳65 PrologToPiTRSProof (⇐)
    ↳66 PiTRS
    ↳67 DependencyPairsProof (⇔)
    ↳68 PiDP
    ↳69 DependencyGraphProof (⇔)
    ↳70 AND
      ↳71 PiDP
        ↳72 UsableRulesProof (⇔)
        ↳73 PiDP
        ↳74 PiDPToQDPProof (⇐)
        ↳75 QDP
        ↳76 QDPSizeChangeProof (⇔)
        ↳77 TRUE
      ↳78 PiDP
        ↳79 UsableRulesProof (⇔)
        ↳80 PiDP
        ↳81 PiDPToQDPProof (⇐)
        ↳82 QDP
          ↳83 Instantiation (⇔)
            ↳84 QDP
          ↳85 Narrowing (⇐)
            ↳86 QDP
            ↳87 Narrowing (⇐)
            ↳88 QDP
            ↳89 Narrowing (⇐)
            ↳90 QDP
            ↳91 Narrowing (⇐)
            ↳92 QDP
            ↳93 Instantiation (⇔)
            ↳94 QDP
            ↳95 Instantiation (⇔)
            ↳96 QDP
            ↳97 Instantiation (⇔)
            ↳98 QDP
            ↳99 Instantiation (⇔)
            ↳100 QDP
            ↳101 Instantiation (⇔)
            ↳102 QDP
            ↳103 Instantiation (⇔)
            ↳104 QDP
            ↳105 Instantiation (⇔)
            ↳106 QDP
            ↳107 Instantiation (⇔)
            ↳108 QDP
            ↳109 Instantiation (⇔)
            ↳110 QDP
            ↳111 Instantiation (⇔)
            ↳112 QDP
            ↳113 Instantiation (⇔)
            ↳114 QDP
            ↳115 Instantiation (⇔)
            ↳116 QDP
            ↳117 ForwardInstantiation (⇔)
            ↳118 QDP
            ↳119 ForwardInstantiation (⇔)
            ↳120 QDP
            ↳121 ForwardInstantiation (⇔)
            ↳122 QDP
            ↳123 ForwardInstantiation (⇔)
            ↳124 QDP
            ↳125 ForwardInstantiation (⇔)
            ↳126 QDP
            ↳127 ForwardInstantiation (⇔)
            ↳128 QDP
            ↳129 NonTerminationProof (⇔)
            ↳130 FALSE

(0) Obligation:

Clauses:

member(H, .(H, L)).
member(X, .(H, L)) :- member(X, L).
turing(t(X, Y, Z), S, P, t(X, Y, Z)) :- member(p(S, Y, halt, W, D), P).
turing(t(X, Y, .(R, L)), S, P, T) :- ','(member(p(S, Y, S1, W, r), P), turing(t(.(W, X), R, L), S1, P, T)).
turing(t(X, Y, []), S, P, T) :- ','(member(p(S, Y, S1, W, r), P), turing(t(.(W, X), space, []), S1, P, T)).
turing(t(.(X, L), Y, R), S, P, T) :- ','(member(p(S, Y, S1, W, l), P), turing(t(L, X, .(W, R)), S1, P, T)).
turing(t([], Y, R), S, P, T) :- ','(member(p(S, Y, S1, W, l), P), turing(t([], space, .(W, R)), S1, P, T)).

Queries:

turing(g,g,g,a).

(1) PrologToPiTRSProof (SOUND transformation)

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

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x4, x5, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1, x2)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x2, x3, x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x1, x2, x3, x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x2, x3, x4, x5, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x1, x2, x3, x4, x5, x6, x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x5, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x1, x3, x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x2, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x1, x2, x3, x4, x6, x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x2, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x1, x2, x4, x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x3, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x1, x2, x3, x4, x6, x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x1, x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x1, x2, x4, x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x2, x3, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x1, x2, x3, x4, x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x3, x4, x5, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x1, x2, x3, x4, x5, x6, x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x1, x2, x3, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x1, x2, x3, x4, x6)

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog

(2) Obligation:

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

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x4, x5, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1, x2)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x2, x3, x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x1, x2, x3, x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x2, x3, x4, x5, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x1, x2, x3, x4, x5, x6, x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x5, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x1, x3, x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x2, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x1, x2, x3, x4, x6, x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x2, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x1, x2, x4, x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x3, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x1, x2, x3, x4, x6, x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x1, x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x1, x2, x4, x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x2, x3, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x1, x2, x3, x4, x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x3, x4, x5, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x1, x2, x3, x4, x5, x6, x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x1, x2, x3, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x1, x2, x3, x4, x6)

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

TURING_IN_GGGA(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_GGGA(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
TURING_IN_GGGA(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN_AG(p(S, Y, halt, W, D), P)
MEMBER_IN_AG(X, .(H, L)) → U1_AG(X, H, L, member_in_ag(X, L))
MEMBER_IN_AG(X, .(H, L)) → MEMBER_IN_AG(X, L)
TURING_IN_GGGA(t(X, Y, .(R, L)), S, P, T) → U3_GGGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GGGA(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U3_GGGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_GGGA(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
U3_GGGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_GAGA(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
TURING_IN_GAGA(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN_AG(p(S, Y, halt, W, D), P)
TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → U3_GAGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_GAGA(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, []), S, P, T) → U5_GAGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GAGA(t(X, Y, []), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_GAGA(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → U7_GAGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_GAGA(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GAGA(t([], Y, R), S, P, T) → U9_GAGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GAGA(t([], Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_GAGA(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)
TURING_IN_GGGA(t(X, Y, []), S, P, T) → U5_GGGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GGGA(t(X, Y, []), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U5_GGGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_GGGA(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U5_GGGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GGGA(t(.(X, L), Y, R), S, P, T) → U7_GGGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GGGA(t(.(X, L), Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U7_GGGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_GGGA(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U7_GGGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GGGA(t([], Y, R), S, P, T) → U9_GGGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GGGA(t([], Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U9_GGGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_GGGA(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U9_GGGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)

The TRS R consists of the following rules:

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x4, x5, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1, x2)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x2, x3, x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x1, x2, x3, x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x2, x3, x4, x5, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x1, x2, x3, x4, x5, x6, x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x5, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x1, x3, x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x2, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x1, x2, x3, x4, x6, x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x2, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x1, x2, x4, x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x3, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x1, x2, x3, x4, x6, x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x1, x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x1, x2, x4, x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x2, x3, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x1, x2, x3, x4, x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x3, x4, x5, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x1, x2, x3, x4, x5, x6, x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x1, x2, x3, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x1, x2, x3, x4, x6)
TURING_IN_GGGA(x1, x2, x3, x4)  =  TURING_IN_GGGA(x1, x2, x3)
U2_GGGA(x1, x2, x3, x4, x5, x6)  =  U2_GGGA(x1, x2, x3, x4, x5, x6)
MEMBER_IN_AG(x1, x2)  =  MEMBER_IN_AG(x2)
U1_AG(x1, x2, x3, x4)  =  U1_AG(x2, x3, x4)
U3_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GGGA(x1, x2, x3, x4, x5, x6, x8)
U4_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_GGGA(x1, x2, x3, x4, x5, x6, x8)
TURING_IN_GAGA(x1, x2, x3, x4)  =  TURING_IN_GAGA(x1, x3)
U2_GAGA(x1, x2, x3, x4, x5, x6)  =  U2_GAGA(x1, x2, x3, x5, x6)
U3_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAGA(x1, x2, x3, x4, x6, x8)
U4_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_GAGA(x1, x2, x3, x4, x6, x8)
U5_GAGA(x1, x2, x3, x4, x5, x6)  =  U5_GAGA(x1, x2, x4, x6)
U6_GAGA(x1, x2, x3, x4, x5, x6)  =  U6_GAGA(x1, x2, x4, x6)
U7_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAGA(x1, x2, x3, x4, x6, x8)
U8_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAGA(x1, x2, x3, x4, x6, x8)
U9_GAGA(x1, x2, x3, x4, x5, x6)  =  U9_GAGA(x1, x2, x4, x6)
U10_GAGA(x1, x2, x3, x4, x5, x6)  =  U10_GAGA(x1, x2, x4, x6)
U5_GGGA(x1, x2, x3, x4, x5, x6)  =  U5_GGGA(x1, x2, x3, x4, x6)
U6_GGGA(x1, x2, x3, x4, x5, x6)  =  U6_GGGA(x1, x2, x3, x4, x6)
U7_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GGGA(x1, x2, x3, x4, x5, x6, x8)
U8_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GGGA(x1, x2, x3, x4, x5, x6, x8)
U9_GGGA(x1, x2, x3, x4, x5, x6)  =  U9_GGGA(x1, x2, x3, x4, x6)
U10_GGGA(x1, x2, x3, x4, x5, x6)  =  U10_GGGA(x1, x2, x3, x4, x6)

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

(4) Obligation:

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

TURING_IN_GGGA(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_GGGA(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
TURING_IN_GGGA(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN_AG(p(S, Y, halt, W, D), P)
MEMBER_IN_AG(X, .(H, L)) → U1_AG(X, H, L, member_in_ag(X, L))
MEMBER_IN_AG(X, .(H, L)) → MEMBER_IN_AG(X, L)
TURING_IN_GGGA(t(X, Y, .(R, L)), S, P, T) → U3_GGGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GGGA(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U3_GGGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_GGGA(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
U3_GGGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_GAGA(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
TURING_IN_GAGA(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN_AG(p(S, Y, halt, W, D), P)
TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → U3_GAGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_GAGA(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, []), S, P, T) → U5_GAGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GAGA(t(X, Y, []), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_GAGA(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → U7_GAGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_GAGA(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GAGA(t([], Y, R), S, P, T) → U9_GAGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GAGA(t([], Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_GAGA(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)
TURING_IN_GGGA(t(X, Y, []), S, P, T) → U5_GGGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GGGA(t(X, Y, []), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U5_GGGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_GGGA(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U5_GGGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GGGA(t(.(X, L), Y, R), S, P, T) → U7_GGGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GGGA(t(.(X, L), Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U7_GGGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_GGGA(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U7_GGGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GGGA(t([], Y, R), S, P, T) → U9_GGGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GGGA(t([], Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U9_GGGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_GGGA(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U9_GGGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)

The TRS R consists of the following rules:

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x4, x5, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1, x2)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x2, x3, x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x1, x2, x3, x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x2, x3, x4, x5, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x1, x2, x3, x4, x5, x6, x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x5, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x1, x3, x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x2, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x1, x2, x3, x4, x6, x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x2, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x1, x2, x4, x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x3, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x1, x2, x3, x4, x6, x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x1, x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x1, x2, x4, x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x2, x3, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x1, x2, x3, x4, x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x3, x4, x5, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x1, x2, x3, x4, x5, x6, x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x1, x2, x3, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x1, x2, x3, x4, x6)
TURING_IN_GGGA(x1, x2, x3, x4)  =  TURING_IN_GGGA(x1, x2, x3)
U2_GGGA(x1, x2, x3, x4, x5, x6)  =  U2_GGGA(x1, x2, x3, x4, x5, x6)
MEMBER_IN_AG(x1, x2)  =  MEMBER_IN_AG(x2)
U1_AG(x1, x2, x3, x4)  =  U1_AG(x2, x3, x4)
U3_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GGGA(x1, x2, x3, x4, x5, x6, x8)
U4_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_GGGA(x1, x2, x3, x4, x5, x6, x8)
TURING_IN_GAGA(x1, x2, x3, x4)  =  TURING_IN_GAGA(x1, x3)
U2_GAGA(x1, x2, x3, x4, x5, x6)  =  U2_GAGA(x1, x2, x3, x5, x6)
U3_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAGA(x1, x2, x3, x4, x6, x8)
U4_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_GAGA(x1, x2, x3, x4, x6, x8)
U5_GAGA(x1, x2, x3, x4, x5, x6)  =  U5_GAGA(x1, x2, x4, x6)
U6_GAGA(x1, x2, x3, x4, x5, x6)  =  U6_GAGA(x1, x2, x4, x6)
U7_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAGA(x1, x2, x3, x4, x6, x8)
U8_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAGA(x1, x2, x3, x4, x6, x8)
U9_GAGA(x1, x2, x3, x4, x5, x6)  =  U9_GAGA(x1, x2, x4, x6)
U10_GAGA(x1, x2, x3, x4, x5, x6)  =  U10_GAGA(x1, x2, x4, x6)
U5_GGGA(x1, x2, x3, x4, x5, x6)  =  U5_GGGA(x1, x2, x3, x4, x6)
U6_GGGA(x1, x2, x3, x4, x5, x6)  =  U6_GGGA(x1, x2, x3, x4, x6)
U7_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GGGA(x1, x2, x3, x4, x5, x6, x8)
U8_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GGGA(x1, x2, x3, x4, x5, x6, x8)
U9_GGGA(x1, x2, x3, x4, x5, x6)  =  U9_GGGA(x1, x2, x3, x4, x6)
U10_GGGA(x1, x2, x3, x4, x5, x6)  =  U10_GGGA(x1, x2, x3, x4, x6)

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

(5) DependencyGraphProof (EQUIVALENT transformation)

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

(6) Complex Obligation (AND)

(7) Obligation:

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

MEMBER_IN_AG(X, .(H, L)) → MEMBER_IN_AG(X, L)

The TRS R consists of the following rules:

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x4, x5, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1, x2)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x2, x3, x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x1, x2, x3, x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x2, x3, x4, x5, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x1, x2, x3, x4, x5, x6, x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x5, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x1, x3, x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x2, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x1, x2, x3, x4, x6, x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x2, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x1, x2, x4, x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x3, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x1, x2, x3, x4, x6, x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x1, x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x1, x2, x4, x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x2, x3, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x1, x2, x3, x4, x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x3, x4, x5, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x1, x2, x3, x4, x5, x6, x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x1, x2, x3, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x1, x2, x3, x4, x6)
MEMBER_IN_AG(x1, x2)  =  MEMBER_IN_AG(x2)

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

(8) UsableRulesProof (EQUIVALENT transformation)

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

(9) Obligation:

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

MEMBER_IN_AG(X, .(H, L)) → MEMBER_IN_AG(X, L)

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

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

(10) PiDPToQDPProof (SOUND transformation)

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

(11) Obligation:

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

MEMBER_IN_AG(.(H, L)) → MEMBER_IN_AG(L)

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

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

  • MEMBER_IN_AG(.(H, L)) → MEMBER_IN_AG(L)
    The graph contains the following edges 1 > 1

(13) TRUE

(14) Obligation:

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

TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → U3_GAGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, []), S, P, T) → U5_GAGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → U7_GAGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GAGA(t([], Y, R), S, P, T) → U9_GAGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)

The TRS R consists of the following rules:

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x4, x5, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1, x2)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x2, x3, x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x1, x2, x3, x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x2, x3, x4, x5, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x1, x2, x3, x4, x5, x6, x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x5, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x1, x3, x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x2, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x1, x2, x3, x4, x6, x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x2, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x1, x2, x4, x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x3, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x1, x2, x3, x4, x6, x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x1, x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x1, x2, x4, x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x2, x3, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x1, x2, x3, x4, x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x3, x4, x5, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x1, x2, x3, x4, x5, x6, x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x1, x2, x3, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x1, x2, x3, x4, x6)
TURING_IN_GAGA(x1, x2, x3, x4)  =  TURING_IN_GAGA(x1, x3)
U3_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAGA(x1, x2, x3, x4, x6, x8)
U5_GAGA(x1, x2, x3, x4, x5, x6)  =  U5_GAGA(x1, x2, x4, x6)
U7_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAGA(x1, x2, x3, x4, x6, x8)
U9_GAGA(x1, x2, x3, x4, x5, x6)  =  U9_GAGA(x1, x2, x4, x6)

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

(15) UsableRulesProof (EQUIVALENT transformation)

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

(16) Obligation:

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

TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → U3_GAGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, []), S, P, T) → U5_GAGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → U7_GAGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GAGA(t([], Y, R), S, P, T) → U9_GAGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)

The TRS R consists of the following rules:

member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The argument filtering Pi contains the following mapping:
t(x1, x2, x3)  =  t(x1, x2, x3)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1, x2)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x2, x3, x4)
[]  =  []
space  =  space
TURING_IN_GAGA(x1, x2, x3, x4)  =  TURING_IN_GAGA(x1, x3)
U3_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAGA(x1, x2, x3, x4, x6, x8)
U5_GAGA(x1, x2, x3, x4, x5, x6)  =  U5_GAGA(x1, x2, x4, x6)
U7_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAGA(x1, x2, x3, x4, x6, x8)
U9_GAGA(x1, x2, x3, x4, x5, x6)  =  U9_GAGA(x1, x2, x4, x6)

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

(17) PiDPToQDPProof (SOUND transformation)

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

(18) Obligation:

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

TURING_IN_GAGA(t(X, Y, .(R, L)), P) → U3_GAGA(X, Y, R, L, P, member_in_ag(P))
U3_GAGA(X, Y, R, L, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), R, L), P)
TURING_IN_GAGA(t(X, Y, []), P) → U5_GAGA(X, Y, P, member_in_ag(P))
U5_GAGA(X, Y, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), space, []), P)
TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, Y, R, P, member_in_ag(P))
U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(Y, R, P, member_in_ag(P))
U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(19) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t(X, Y, []), P) → U5_GAGA(X, Y, P, member_in_ag(P)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(z5, z0), z2, []), z4) → U5_GAGA(.(z5, z0), z2, z4, member_in_ag(z4))
TURING_IN_GAGA(t(.(z3, z0), space, []), z2) → U5_GAGA(.(z3, z0), space, z2, member_in_ag(z2))

(20) Obligation:

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

TURING_IN_GAGA(t(X, Y, .(R, L)), P) → U3_GAGA(X, Y, R, L, P, member_in_ag(P))
U3_GAGA(X, Y, R, L, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), R, L), P)
U5_GAGA(X, Y, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), space, []), P)
TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, Y, R, P, member_in_ag(P))
U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(Y, R, P, member_in_ag(P))
U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(.(z5, z0), z2, []), z4) → U5_GAGA(.(z5, z0), z2, z4, member_in_ag(z4))
TURING_IN_GAGA(t(.(z3, z0), space, []), z2) → U5_GAGA(.(z3, z0), space, z2, member_in_ag(z2))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(21) Narrowing (SOUND transformation)

By narrowing [LPAR04] the rule TURING_IN_GAGA(t(X, Y, .(R, L)), P) → U3_GAGA(X, Y, R, L, P, member_in_ag(P)) at position [5] we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))

(22) Obligation:

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

U3_GAGA(X, Y, R, L, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), R, L), P)
TURING_IN_GAGA(t(X, Y, []), P) → U5_GAGA(X, Y, P, member_in_ag(P))
U5_GAGA(X, Y, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), space, []), P)
TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, Y, R, P, member_in_ag(P))
U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(Y, R, P, member_in_ag(P))
U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(23) Narrowing (SOUND transformation)

By narrowing [LPAR04] the rule TURING_IN_GAGA(t(X, Y, []), P) → U5_GAGA(X, Y, P, member_in_ag(P)) at position [3] we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))

(24) Obligation:

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

U3_GAGA(X, Y, R, L, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), R, L), P)
U5_GAGA(X, Y, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), space, []), P)
TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, Y, R, P, member_in_ag(P))
U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(Y, R, P, member_in_ag(P))
U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(25) Narrowing (SOUND transformation)

By narrowing [LPAR04] the rule TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, Y, R, P, member_in_ag(P)) at position [5] we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))

(26) Obligation:

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

U3_GAGA(X, Y, R, L, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), R, L), P)
U5_GAGA(X, Y, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), space, []), P)
U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(Y, R, P, member_in_ag(P))
U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(27) Narrowing (SOUND transformation)

By narrowing [LPAR04] the rule TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(Y, R, P, member_in_ag(P)) at position [3] we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))

(28) Obligation:

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

U3_GAGA(X, Y, R, L, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), R, L), P)
U5_GAGA(X, Y, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), space, []), P)
U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(29) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U3_GAGA(X, Y, R, L, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), R, L), P) we obtained the following new rules [LPAR04]:

U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))

(30) Obligation:

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

U5_GAGA(X, Y, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), space, []), P)
U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(31) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U5_GAGA(X, Y, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(.(W, X), space, []), P) we obtained the following new rules [LPAR04]:

U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))

(32) Obligation:

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

U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(33) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U7_GAGA(X, L, Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), P) we obtained the following new rules [LPAR04]:

U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))

(34) Obligation:

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

U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(35) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U9_GAGA(Y, R, P, member_out_ag(p(Y, W), P)) → TURING_IN_GAGA(t([], space, .(W, R)), P) we obtained the following new rules [LPAR04]:

U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))

(36) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(37) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))

(38) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(39) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))

(40) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(41) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), member_out_ag(x0, .(x0, x1))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))

(42) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(43) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y0, y1, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))

(44) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(45) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U5_GAGA(z0, z1, .(p(z1, x3), z3), member_out_ag(p(z1, x3), .(p(z1, x3), z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(z1, x3), z3)) we obtained the following new rules [LPAR04]:

U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))

(46) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(47) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U5_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z1, x3), .(z2, z3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3)) we obtained the following new rules [LPAR04]:

U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x4), z4), member_out_ag(p(z2, x4), .(p(z2, x4), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, x4), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x4), z3), member_out_ag(p(space, x4), .(p(space, x4), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(space, x4), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))

(48) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(49) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U9_GAGA(z0, z1, .(p(z0, x3), z3), member_out_ag(p(z0, x3), .(p(z0, x3), z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(z0, x3), z3)) we obtained the following new rules [LPAR04]:

U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))

(50) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))
U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(51) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U9_GAGA(z0, z1, .(z2, z3), member_out_ag(p(z0, x3), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3)) we obtained the following new rules [LPAR04]:

U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x4), z4), member_out_ag(p(z0, x4), .(p(z0, x4), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z0, x4), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x4), z3), member_out_ag(p(space, x4), .(p(space, x4), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(space, x4), z3))
U9_GAGA(z0, .(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z0, x4), .(p(z3, z1), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(z0, .(z1, z2), .(z3, z4), member_out_ag(p(z0, x4), .(z3, z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
U9_GAGA(space, .(z0, z1), .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(z2, z0), z3))
U9_GAGA(space, .(z0, z1), .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(z2, z3))

(52) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))
U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))
U9_GAGA(z0, .(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z0, x4), .(p(z3, z1), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(z0, .(z1, z2), .(z3, z4), member_out_ag(p(z0, x4), .(z3, z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
U9_GAGA(space, .(z0, z1), .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(z2, z0), z3))
U9_GAGA(space, .(z0, z1), .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(z2, z3))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(53) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_4, y_5), x5)) → U3_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))

(54) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))
U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))
U9_GAGA(z0, .(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z0, x4), .(p(z3, z1), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(z0, .(z1, z2), .(z3, z4), member_out_ag(p(z0, x4), .(z3, z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
U9_GAGA(space, .(z0, z1), .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(z2, z0), z3))
U9_GAGA(space, .(z0, z1), .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(z2, z3))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_4, y_5), x5)) → U3_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(55) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), member_out_ag(x0, .(x0, x1))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_4, y_5), x5)) → U7_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))

(56) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))
U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))
U9_GAGA(z0, .(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z0, x4), .(p(z3, z1), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(z0, .(z1, z2), .(z3, z4), member_out_ag(p(z0, x4), .(z3, z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
U9_GAGA(space, .(z0, z1), .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(z2, z0), z3))
U9_GAGA(space, .(z0, z1), .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(z2, z3))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_4, y_5), x5)) → U3_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_4, y_5), x5)) → U7_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(57) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), member_out_ag(z4, .(z4, z5))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_3, y_4), x4)) → U5_GAGA(.(x0, x1), x2, .(p(y_3, y_4), x4), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x4)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(space, y_2), x4)) → U5_GAGA(.(x0, x1), space, .(p(space, y_2), x4), member_out_ag(p(space, y_2), .(p(space, y_2), x4)))

(58) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))
U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))
U9_GAGA(z0, .(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z0, x4), .(p(z3, z1), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(z0, .(z1, z2), .(z3, z4), member_out_ag(p(z0, x4), .(z3, z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
U9_GAGA(space, .(z0, z1), .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(z2, z0), z3))
U9_GAGA(space, .(z0, z1), .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(z2, z3))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_4, y_5), x5)) → U3_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_4, y_5), x5)) → U7_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_3, y_4), x4)) → U5_GAGA(.(x0, x1), x2, .(p(y_3, y_4), x4), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x4)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(space, y_2), x4)) → U5_GAGA(.(x0, x1), space, .(p(space, y_2), x4), member_out_ag(p(space, y_2), .(p(space, y_2), x4)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(59) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), member_out_ag(z2, .(z2, z3))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(y_3, y_4), x3)) → U5_GAGA(.(x0, x1), space, .(p(y_3, y_4), x3), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x3)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(space, y_2), x3)) → U5_GAGA(.(x0, x1), space, .(p(space, y_2), x3), member_out_ag(p(space, y_2), .(p(space, y_2), x3)))

(60) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))
U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))
U9_GAGA(z0, .(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z0, x4), .(p(z3, z1), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(z0, .(z1, z2), .(z3, z4), member_out_ag(p(z0, x4), .(z3, z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
U9_GAGA(space, .(z0, z1), .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(z2, z0), z3))
U9_GAGA(space, .(z0, z1), .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(z2, z3))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_4, y_5), x5)) → U3_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_4, y_5), x5)) → U7_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_3, y_4), x4)) → U5_GAGA(.(x0, x1), x2, .(p(y_3, y_4), x4), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x4)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(space, y_2), x4)) → U5_GAGA(.(x0, x1), space, .(p(space, y_2), x4), member_out_ag(p(space, y_2), .(p(space, y_2), x4)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(y_3, y_4), x3)) → U5_GAGA(.(x0, x1), space, .(p(y_3, y_4), x3), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(61) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), member_out_ag(z4, .(z4, z5))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], x0, .(x1, x2)), .(p(y_3, y_4), x4)) → U9_GAGA(x0, .(x1, x2), .(p(y_3, y_4), x4), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x4)))
TURING_IN_GAGA(t([], space, .(x1, x2)), .(p(space, y_2), x4)) → U9_GAGA(space, .(x1, x2), .(p(space, y_2), x4), member_out_ag(p(space, y_2), .(p(space, y_2), x4)))

(62) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))
U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))
U9_GAGA(z0, .(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z0, x4), .(p(z3, z1), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(z0, .(z1, z2), .(z3, z4), member_out_ag(p(z0, x4), .(z3, z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
U9_GAGA(space, .(z0, z1), .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(z2, z0), z3))
U9_GAGA(space, .(z0, z1), .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(z2, z3))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_4, y_5), x5)) → U3_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_4, y_5), x5)) → U7_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_3, y_4), x4)) → U5_GAGA(.(x0, x1), x2, .(p(y_3, y_4), x4), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x4)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(space, y_2), x4)) → U5_GAGA(.(x0, x1), space, .(p(space, y_2), x4), member_out_ag(p(space, y_2), .(p(space, y_2), x4)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(y_3, y_4), x3)) → U5_GAGA(.(x0, x1), space, .(p(y_3, y_4), x3), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x3)))
TURING_IN_GAGA(t([], x0, .(x1, x2)), .(p(y_3, y_4), x4)) → U9_GAGA(x0, .(x1, x2), .(p(y_3, y_4), x4), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x4)))
TURING_IN_GAGA(t([], space, .(x1, x2)), .(p(space, y_2), x4)) → U9_GAGA(space, .(x1, x2), .(p(space, y_2), x4), member_out_ag(p(space, y_2), .(p(space, y_2), x4)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(63) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), member_out_ag(z2, .(z2, z3))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], space, .(x0, x1)), .(p(y_3, y_4), x3)) → U9_GAGA(space, .(x0, x1), .(p(y_3, y_4), x3), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x3)))
TURING_IN_GAGA(t([], space, .(x0, x1)), .(p(space, y_2), x3)) → U9_GAGA(space, .(x0, x1), .(p(space, y_2), x3), member_out_ag(p(space, y_2), .(p(space, y_2), x3)))

(64) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y2, y3, .(x0, x1), U1_ag(x0, x1, member_in_ag(x1)))
U3_GAGA(z0, z1, z2, z3, .(p(z1, x5), z5), member_out_ag(p(z1, x5), .(p(z1, x5), z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(z1, x5), z5))
U3_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z1, x5), .(z4, z5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z2, z3, .(p(z2, x5), z5), member_out_ag(p(z2, x5), .(p(z2, x5), z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(z2, x5), z5))
U7_GAGA(z0, z1, z2, z3, .(z4, z5), member_out_ag(p(z2, x5), .(z4, z5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), member_out_ag(p(z1, z4), .(p(z1, z4), z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), member_out_ag(p(z1, z2), .(p(z1, z2), z3)))
TURING_IN_GAGA(t(.(z4, z0), z2, []), .(p(z1, z4), z5)) → U5_GAGA(.(z4, z0), z2, .(p(z1, z4), z5), U1_ag(p(z1, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z2, []), .(z4, z5)) → U5_GAGA(.(z6, z0), z2, .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), space, .(p(z1, z2), z3), U1_ag(p(z1, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z2, z3)) → U5_GAGA(.(z4, z0), space, .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), member_out_ag(p(z2, z4), .(p(z2, z4), z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), member_out_ag(p(z0, z2), .(p(z0, z2), z3)))
TURING_IN_GAGA(t([], z0, .(z4, z3)), .(p(z2, z4), z5)) → U9_GAGA(z0, .(z4, z3), .(p(z2, z4), z5), U1_ag(p(z2, z4), z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z3)), .(z4, z5)) → U9_GAGA(z0, .(z6, z3), .(z4, z5), U1_ag(z4, z5, member_in_ag(z5)))
TURING_IN_GAGA(t([], space, .(z2, z1)), .(p(z0, z2), z3)) → U9_GAGA(space, .(z2, z1), .(p(z0, z2), z3), U1_ag(p(z0, z2), z3, member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z1)), .(z2, z3)) → U9_GAGA(space, .(z4, z1), .(z2, z3), U1_ag(z2, z3, member_in_ag(z3)))
U5_GAGA(.(z0, z1), z2, .(p(z2, z0), z4), member_out_ag(p(z2, z0), .(p(z2, z0), z4))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z2, z0), z4))
U5_GAGA(.(z0, z1), z2, .(p(z2, x2), z4), member_out_ag(p(z2, x2), .(p(z2, x2), z4))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(z2, x2), z4))
U5_GAGA(.(z0, z1), space, .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(space, z0), z3))
U5_GAGA(.(z0, z1), space, .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(space, x2), z3))
U5_GAGA(.(z0, z1), z2, .(p(z3, z0), z4), member_out_ag(p(z2, x4), .(p(z3, z0), z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), z2, .(z3, z4), member_out_ag(p(z2, x4), .(z3, z4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U5_GAGA(.(z0, z1), space, .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z2, z0), z3))
U5_GAGA(.(z0, z1), space, .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z2, z3))
U9_GAGA(z0, .(z1, z2), .(p(z0, z1), z4), member_out_ag(p(z0, z1), .(p(z0, z1), z4))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z0, z1), z4))
U9_GAGA(z0, .(z1, z2), .(p(z0, x2), z4), member_out_ag(p(z0, x2), .(p(z0, x2), z4))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(z0, x2), z4))
U9_GAGA(space, .(z0, z1), .(p(space, z0), z3), member_out_ag(p(space, z0), .(p(space, z0), z3))) → TURING_IN_GAGA(t([], space, .(z0, .(z0, z1))), .(p(space, z0), z3))
U9_GAGA(space, .(z0, z1), .(p(space, x2), z3), member_out_ag(p(space, x2), .(p(space, x2), z3))) → TURING_IN_GAGA(t([], space, .(x2, .(z0, z1))), .(p(space, x2), z3))
U9_GAGA(z0, .(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z0, x4), .(p(z3, z1), z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(z0, .(z1, z2), .(z3, z4), member_out_ag(p(z0, x4), .(z3, z4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
U9_GAGA(space, .(z0, z1), .(p(z2, z0), z3), member_out_ag(p(space, x4), .(p(z2, z0), z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(p(z2, z0), z3))
U9_GAGA(space, .(z0, z1), .(z2, z3), member_out_ag(p(space, x4), .(z2, z3))) → TURING_IN_GAGA(t([], space, .(x4, .(z0, z1))), .(z2, z3))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_4, y_5), x5)) → U3_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_4, y_5), x5)) → U7_GAGA(x0, x1, x2, x3, .(p(y_4, y_5), x5), member_out_ag(p(y_4, y_5), .(p(y_4, y_5), x5)))
TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_3, y_4), x4)) → U5_GAGA(.(x0, x1), x2, .(p(y_3, y_4), x4), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x4)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(space, y_2), x4)) → U5_GAGA(.(x0, x1), space, .(p(space, y_2), x4), member_out_ag(p(space, y_2), .(p(space, y_2), x4)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(y_3, y_4), x3)) → U5_GAGA(.(x0, x1), space, .(p(y_3, y_4), x3), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x3)))
TURING_IN_GAGA(t([], x0, .(x1, x2)), .(p(y_3, y_4), x4)) → U9_GAGA(x0, .(x1, x2), .(p(y_3, y_4), x4), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x4)))
TURING_IN_GAGA(t([], space, .(x1, x2)), .(p(space, y_2), x4)) → U9_GAGA(space, .(x1, x2), .(p(space, y_2), x4), member_out_ag(p(space, y_2), .(p(space, y_2), x4)))
TURING_IN_GAGA(t([], space, .(x0, x1)), .(p(y_3, y_4), x3)) → U9_GAGA(space, .(x0, x1), .(p(y_3, y_4), x3), member_out_ag(p(y_3, y_4), .(p(y_3, y_4), x3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(.(H, L)) → U1_ag(H, L, member_in_ag(L))
U1_ag(H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0, x1, x2)

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

(65) PrologToPiTRSProof (SOUND transformation)

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

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x3, x4, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x4, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x2, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x6)

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog

(66) Obligation:

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

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x3, x4, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x4, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x2, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x6)

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

TURING_IN_GGGA(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_GGGA(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
TURING_IN_GGGA(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN_AG(p(S, Y, halt, W, D), P)
MEMBER_IN_AG(X, .(H, L)) → U1_AG(X, H, L, member_in_ag(X, L))
MEMBER_IN_AG(X, .(H, L)) → MEMBER_IN_AG(X, L)
TURING_IN_GGGA(t(X, Y, .(R, L)), S, P, T) → U3_GGGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GGGA(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U3_GGGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_GGGA(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
U3_GGGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_GAGA(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
TURING_IN_GAGA(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN_AG(p(S, Y, halt, W, D), P)
TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → U3_GAGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_GAGA(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, []), S, P, T) → U5_GAGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GAGA(t(X, Y, []), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_GAGA(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → U7_GAGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_GAGA(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GAGA(t([], Y, R), S, P, T) → U9_GAGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GAGA(t([], Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_GAGA(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)
TURING_IN_GGGA(t(X, Y, []), S, P, T) → U5_GGGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GGGA(t(X, Y, []), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U5_GGGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_GGGA(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U5_GGGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GGGA(t(.(X, L), Y, R), S, P, T) → U7_GGGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GGGA(t(.(X, L), Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U7_GGGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_GGGA(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U7_GGGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GGGA(t([], Y, R), S, P, T) → U9_GGGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GGGA(t([], Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U9_GGGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_GGGA(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U9_GGGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)

The TRS R consists of the following rules:

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x3, x4, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x4, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x2, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x6)
TURING_IN_GGGA(x1, x2, x3, x4)  =  TURING_IN_GGGA(x1, x2, x3)
U2_GGGA(x1, x2, x3, x4, x5, x6)  =  U2_GGGA(x1, x2, x3, x6)
MEMBER_IN_AG(x1, x2)  =  MEMBER_IN_AG(x2)
U1_AG(x1, x2, x3, x4)  =  U1_AG(x4)
U3_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GGGA(x1, x3, x4, x6, x8)
U4_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_GGGA(x8)
TURING_IN_GAGA(x1, x2, x3, x4)  =  TURING_IN_GAGA(x1, x3)
U2_GAGA(x1, x2, x3, x4, x5, x6)  =  U2_GAGA(x1, x2, x3, x6)
U3_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAGA(x1, x3, x4, x6, x8)
U4_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_GAGA(x8)
U5_GAGA(x1, x2, x3, x4, x5, x6)  =  U5_GAGA(x1, x4, x6)
U6_GAGA(x1, x2, x3, x4, x5, x6)  =  U6_GAGA(x6)
U7_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAGA(x1, x2, x4, x6, x8)
U8_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAGA(x8)
U9_GAGA(x1, x2, x3, x4, x5, x6)  =  U9_GAGA(x2, x4, x6)
U10_GAGA(x1, x2, x3, x4, x5, x6)  =  U10_GAGA(x6)
U5_GGGA(x1, x2, x3, x4, x5, x6)  =  U5_GGGA(x1, x4, x6)
U6_GGGA(x1, x2, x3, x4, x5, x6)  =  U6_GGGA(x6)
U7_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GGGA(x1, x2, x4, x6, x8)
U8_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GGGA(x8)
U9_GGGA(x1, x2, x3, x4, x5, x6)  =  U9_GGGA(x2, x4, x6)
U10_GGGA(x1, x2, x3, x4, x5, x6)  =  U10_GGGA(x6)

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

(68) Obligation:

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

TURING_IN_GGGA(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_GGGA(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
TURING_IN_GGGA(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN_AG(p(S, Y, halt, W, D), P)
MEMBER_IN_AG(X, .(H, L)) → U1_AG(X, H, L, member_in_ag(X, L))
MEMBER_IN_AG(X, .(H, L)) → MEMBER_IN_AG(X, L)
TURING_IN_GGGA(t(X, Y, .(R, L)), S, P, T) → U3_GGGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GGGA(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U3_GGGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_GGGA(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
U3_GGGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_GAGA(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
TURING_IN_GAGA(t(X, Y, Z), S, P, t(X, Y, Z)) → MEMBER_IN_AG(p(S, Y, halt, W, D), P)
TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → U3_GAGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_GAGA(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, []), S, P, T) → U5_GAGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GAGA(t(X, Y, []), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_GAGA(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → U7_GAGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_GAGA(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GAGA(t([], Y, R), S, P, T) → U9_GAGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GAGA(t([], Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_GAGA(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)
TURING_IN_GGGA(t(X, Y, []), S, P, T) → U5_GGGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
TURING_IN_GGGA(t(X, Y, []), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, r), P)
U5_GGGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_GGGA(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U5_GGGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GGGA(t(.(X, L), Y, R), S, P, T) → U7_GGGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GGGA(t(.(X, L), Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U7_GGGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_GGGA(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U7_GGGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GGGA(t([], Y, R), S, P, T) → U9_GGGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
TURING_IN_GGGA(t([], Y, R), S, P, T) → MEMBER_IN_AG(p(S, Y, S1, W, l), P)
U9_GGGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_GGGA(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U9_GGGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)

The TRS R consists of the following rules:

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x3, x4, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x4, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x2, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x6)
TURING_IN_GGGA(x1, x2, x3, x4)  =  TURING_IN_GGGA(x1, x2, x3)
U2_GGGA(x1, x2, x3, x4, x5, x6)  =  U2_GGGA(x1, x2, x3, x6)
MEMBER_IN_AG(x1, x2)  =  MEMBER_IN_AG(x2)
U1_AG(x1, x2, x3, x4)  =  U1_AG(x4)
U3_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GGGA(x1, x3, x4, x6, x8)
U4_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_GGGA(x8)
TURING_IN_GAGA(x1, x2, x3, x4)  =  TURING_IN_GAGA(x1, x3)
U2_GAGA(x1, x2, x3, x4, x5, x6)  =  U2_GAGA(x1, x2, x3, x6)
U3_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAGA(x1, x3, x4, x6, x8)
U4_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_GAGA(x8)
U5_GAGA(x1, x2, x3, x4, x5, x6)  =  U5_GAGA(x1, x4, x6)
U6_GAGA(x1, x2, x3, x4, x5, x6)  =  U6_GAGA(x6)
U7_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAGA(x1, x2, x4, x6, x8)
U8_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAGA(x8)
U9_GAGA(x1, x2, x3, x4, x5, x6)  =  U9_GAGA(x2, x4, x6)
U10_GAGA(x1, x2, x3, x4, x5, x6)  =  U10_GAGA(x6)
U5_GGGA(x1, x2, x3, x4, x5, x6)  =  U5_GGGA(x1, x4, x6)
U6_GGGA(x1, x2, x3, x4, x5, x6)  =  U6_GGGA(x6)
U7_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GGGA(x1, x2, x4, x6, x8)
U8_GGGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GGGA(x8)
U9_GGGA(x1, x2, x3, x4, x5, x6)  =  U9_GGGA(x2, x4, x6)
U10_GGGA(x1, x2, x3, x4, x5, x6)  =  U10_GGGA(x6)

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

(69) DependencyGraphProof (EQUIVALENT transformation)

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

(70) Complex Obligation (AND)

(71) Obligation:

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

MEMBER_IN_AG(X, .(H, L)) → MEMBER_IN_AG(X, L)

The TRS R consists of the following rules:

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x3, x4, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x4, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x2, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x6)
MEMBER_IN_AG(x1, x2)  =  MEMBER_IN_AG(x2)

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

(72) UsableRulesProof (EQUIVALENT transformation)

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

(73) Obligation:

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

MEMBER_IN_AG(X, .(H, L)) → MEMBER_IN_AG(X, L)

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

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

(74) PiDPToQDPProof (SOUND transformation)

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

(75) Obligation:

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

MEMBER_IN_AG(.(H, L)) → MEMBER_IN_AG(L)

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

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

  • MEMBER_IN_AG(.(H, L)) → MEMBER_IN_AG(L)
    The graph contains the following edges 1 > 1

(77) TRUE

(78) Obligation:

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

TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → U3_GAGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, []), S, P, T) → U5_GAGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → U7_GAGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GAGA(t([], Y, R), S, P, T) → U9_GAGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)

The TRS R consists of the following rules:

turing_in_ggga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_ggga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))
U2_ggga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_ggga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_ggga(t(X, Y, .(R, L)), S, P, T) → U3_ggga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_ggga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_ggga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, Z), S, P, t(X, Y, Z)) → U2_gaga(X, Y, Z, S, P, member_in_ag(p(S, Y, halt, W, D), P))
U2_gaga(X, Y, Z, S, P, member_out_ag(p(S, Y, halt, W, D), P)) → turing_out_gaga(t(X, Y, Z), S, P, t(X, Y, Z))
turing_in_gaga(t(X, Y, .(R, L)), S, P, T) → U3_gaga(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_gaga(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U4_gaga(X, Y, R, L, S, P, T, turing_in_gaga(t(.(W, X), R, L), S1, P, T))
turing_in_gaga(t(X, Y, []), S, P, T) → U5_gaga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_gaga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_gaga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
turing_in_gaga(t(.(X, L), Y, R), S, P, T) → U7_gaga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_gaga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_gaga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
turing_in_gaga(t([], Y, R), S, P, T) → U9_gaga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_gaga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_gaga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_gaga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_gaga(t([], Y, R), S, P, T)
U8_gaga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_gaga(t(.(X, L), Y, R), S, P, T)
U6_gaga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_gaga(t(X, Y, []), S, P, T)
U4_gaga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_gaga(t(X, Y, .(R, L)), S, P, T)
U4_ggga(X, Y, R, L, S, P, T, turing_out_gaga(t(.(W, X), R, L), S1, P, T)) → turing_out_ggga(t(X, Y, .(R, L)), S, P, T)
turing_in_ggga(t(X, Y, []), S, P, T) → U5_ggga(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_ggga(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → U6_ggga(X, Y, S, P, T, turing_in_gaga(t(.(W, X), space, []), S1, P, T))
U6_ggga(X, Y, S, P, T, turing_out_gaga(t(.(W, X), space, []), S1, P, T)) → turing_out_ggga(t(X, Y, []), S, P, T)
turing_in_ggga(t(.(X, L), Y, R), S, P, T) → U7_ggga(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_ggga(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U8_ggga(X, L, Y, R, S, P, T, turing_in_gaga(t(L, X, .(W, R)), S1, P, T))
U8_ggga(X, L, Y, R, S, P, T, turing_out_gaga(t(L, X, .(W, R)), S1, P, T)) → turing_out_ggga(t(.(X, L), Y, R), S, P, T)
turing_in_ggga(t([], Y, R), S, P, T) → U9_ggga(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_ggga(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → U10_ggga(Y, R, S, P, T, turing_in_gaga(t([], space, .(W, R)), S1, P, T))
U10_ggga(Y, R, S, P, T, turing_out_gaga(t([], space, .(W, R)), S1, P, T)) → turing_out_ggga(t([], Y, R), S, P, T)

The argument filtering Pi contains the following mapping:
turing_in_ggga(x1, x2, x3, x4)  =  turing_in_ggga(x1, x2, x3)
t(x1, x2, x3)  =  t(x1, x2, x3)
U2_ggga(x1, x2, x3, x4, x5, x6)  =  U2_ggga(x1, x2, x3, x6)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x4)
halt  =  halt
turing_out_ggga(x1, x2, x3, x4)  =  turing_out_ggga(x4)
U3_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_ggga(x1, x3, x4, x6, x8)
U4_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_ggga(x8)
turing_in_gaga(x1, x2, x3, x4)  =  turing_in_gaga(x1, x3)
U2_gaga(x1, x2, x3, x4, x5, x6)  =  U2_gaga(x1, x2, x3, x6)
turing_out_gaga(x1, x2, x3, x4)  =  turing_out_gaga(x4)
U3_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaga(x1, x3, x4, x6, x8)
U4_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U4_gaga(x8)
[]  =  []
U5_gaga(x1, x2, x3, x4, x5, x6)  =  U5_gaga(x1, x4, x6)
U6_gaga(x1, x2, x3, x4, x5, x6)  =  U6_gaga(x6)
U7_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaga(x1, x2, x4, x6, x8)
U8_gaga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaga(x8)
U9_gaga(x1, x2, x3, x4, x5, x6)  =  U9_gaga(x2, x4, x6)
U10_gaga(x1, x2, x3, x4, x5, x6)  =  U10_gaga(x6)
space  =  space
U5_ggga(x1, x2, x3, x4, x5, x6)  =  U5_ggga(x1, x4, x6)
U6_ggga(x1, x2, x3, x4, x5, x6)  =  U6_ggga(x6)
U7_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggga(x1, x2, x4, x6, x8)
U8_ggga(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggga(x8)
U9_ggga(x1, x2, x3, x4, x5, x6)  =  U9_ggga(x2, x4, x6)
U10_ggga(x1, x2, x3, x4, x5, x6)  =  U10_ggga(x6)
TURING_IN_GAGA(x1, x2, x3, x4)  =  TURING_IN_GAGA(x1, x3)
U3_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAGA(x1, x3, x4, x6, x8)
U5_GAGA(x1, x2, x3, x4, x5, x6)  =  U5_GAGA(x1, x4, x6)
U7_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAGA(x1, x2, x4, x6, x8)
U9_GAGA(x1, x2, x3, x4, x5, x6)  =  U9_GAGA(x2, x4, x6)

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

(79) UsableRulesProof (EQUIVALENT transformation)

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

(80) Obligation:

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

TURING_IN_GAGA(t(X, Y, .(R, L)), S, P, T) → U3_GAGA(X, Y, R, L, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U3_GAGA(X, Y, R, L, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), R, L), S1, P, T)
TURING_IN_GAGA(t(X, Y, []), S, P, T) → U5_GAGA(X, Y, S, P, T, member_in_ag(p(S, Y, S1, W, r), P))
U5_GAGA(X, Y, S, P, T, member_out_ag(p(S, Y, S1, W, r), P)) → TURING_IN_GAGA(t(.(W, X), space, []), S1, P, T)
TURING_IN_GAGA(t(.(X, L), Y, R), S, P, T) → U7_GAGA(X, L, Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U7_GAGA(X, L, Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t(L, X, .(W, R)), S1, P, T)
TURING_IN_GAGA(t([], Y, R), S, P, T) → U9_GAGA(Y, R, S, P, T, member_in_ag(p(S, Y, S1, W, l), P))
U9_GAGA(Y, R, S, P, T, member_out_ag(p(S, Y, S1, W, l), P)) → TURING_IN_GAGA(t([], space, .(W, R)), S1, P, T)

The TRS R consists of the following rules:

member_in_ag(H, .(H, L)) → member_out_ag(H, .(H, L))
member_in_ag(X, .(H, L)) → U1_ag(X, H, L, member_in_ag(X, L))
U1_ag(X, H, L, member_out_ag(X, L)) → member_out_ag(X, .(H, L))

The argument filtering Pi contains the following mapping:
t(x1, x2, x3)  =  t(x1, x2, x3)
member_in_ag(x1, x2)  =  member_in_ag(x2)
p(x1, x2, x3, x4, x5)  =  p(x2, x4)
.(x1, x2)  =  .(x1, x2)
member_out_ag(x1, x2)  =  member_out_ag(x1)
U1_ag(x1, x2, x3, x4)  =  U1_ag(x4)
[]  =  []
space  =  space
TURING_IN_GAGA(x1, x2, x3, x4)  =  TURING_IN_GAGA(x1, x3)
U3_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAGA(x1, x3, x4, x6, x8)
U5_GAGA(x1, x2, x3, x4, x5, x6)  =  U5_GAGA(x1, x4, x6)
U7_GAGA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAGA(x1, x2, x4, x6, x8)
U9_GAGA(x1, x2, x3, x4, x5, x6)  =  U9_GAGA(x2, x4, x6)

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

(81) PiDPToQDPProof (SOUND transformation)

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

(82) Obligation:

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

TURING_IN_GAGA(t(X, Y, .(R, L)), P) → U3_GAGA(X, R, L, P, member_in_ag(P))
U3_GAGA(X, R, L, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), R, L), P)
TURING_IN_GAGA(t(X, Y, []), P) → U5_GAGA(X, P, member_in_ag(P))
U5_GAGA(X, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), space, []), P)
TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, R, P, member_in_ag(P))
U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(R, P, member_in_ag(P))
U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(83) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t(X, Y, []), P) → U5_GAGA(X, P, member_in_ag(P)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(z5, z0), z1, []), z3) → U5_GAGA(.(z5, z0), z3, member_in_ag(z3))
TURING_IN_GAGA(t(.(z3, z0), space, []), z1) → U5_GAGA(.(z3, z0), z1, member_in_ag(z1))

(84) Obligation:

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

TURING_IN_GAGA(t(X, Y, .(R, L)), P) → U3_GAGA(X, R, L, P, member_in_ag(P))
U3_GAGA(X, R, L, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), R, L), P)
U5_GAGA(X, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), space, []), P)
TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, R, P, member_in_ag(P))
U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(R, P, member_in_ag(P))
U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(.(z5, z0), z1, []), z3) → U5_GAGA(.(z5, z0), z3, member_in_ag(z3))
TURING_IN_GAGA(t(.(z3, z0), space, []), z1) → U5_GAGA(.(z3, z0), z1, member_in_ag(z1))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(85) Narrowing (SOUND transformation)

By narrowing [LPAR04] the rule TURING_IN_GAGA(t(X, Y, .(R, L)), P) → U3_GAGA(X, R, L, P, member_in_ag(P)) at position [4] we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))

(86) Obligation:

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

U3_GAGA(X, R, L, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), R, L), P)
TURING_IN_GAGA(t(X, Y, []), P) → U5_GAGA(X, P, member_in_ag(P))
U5_GAGA(X, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), space, []), P)
TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, R, P, member_in_ag(P))
U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(R, P, member_in_ag(P))
U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(87) Narrowing (SOUND transformation)

By narrowing [LPAR04] the rule TURING_IN_GAGA(t(X, Y, []), P) → U5_GAGA(X, P, member_in_ag(P)) at position [2] we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))

(88) Obligation:

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

U3_GAGA(X, R, L, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), R, L), P)
U5_GAGA(X, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), space, []), P)
TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, R, P, member_in_ag(P))
U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(R, P, member_in_ag(P))
U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(89) Narrowing (SOUND transformation)

By narrowing [LPAR04] the rule TURING_IN_GAGA(t(.(X, L), Y, R), P) → U7_GAGA(X, L, R, P, member_in_ag(P)) at position [4] we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))

(90) Obligation:

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

U3_GAGA(X, R, L, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), R, L), P)
U5_GAGA(X, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), space, []), P)
U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(R, P, member_in_ag(P))
U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(91) Narrowing (SOUND transformation)

By narrowing [LPAR04] the rule TURING_IN_GAGA(t([], Y, R), P) → U9_GAGA(R, P, member_in_ag(P)) at position [2] we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))

(92) Obligation:

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

U3_GAGA(X, R, L, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), R, L), P)
U5_GAGA(X, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), space, []), P)
U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(93) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U3_GAGA(X, R, L, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), R, L), P) we obtained the following new rules [LPAR04]:

U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))

(94) Obligation:

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

U5_GAGA(X, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), space, []), P)
U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(95) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U5_GAGA(X, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(.(W, X), space, []), P) we obtained the following new rules [LPAR04]:

U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))

(96) Obligation:

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

U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P)
U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(97) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U7_GAGA(X, L, R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t(L, X, .(W, R)), P) we obtained the following new rules [LPAR04]:

U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))

(98) Obligation:

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

U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P)
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(99) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U9_GAGA(R, P, member_out_ag(p(Y, W))) → TURING_IN_GAGA(t([], space, .(W, R)), P) we obtained the following new rules [LPAR04]:

U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))

(100) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(101) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), member_out_ag(x0)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))

(102) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(103) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t(y0, y1, []), .(x0, x1)) → U5_GAGA(y0, .(x0, x1), U1_ag(member_in_ag(x1))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))

(104) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(105) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), member_out_ag(x0)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))

(106) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(107) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule TURING_IN_GAGA(t([], y0, y1), .(x0, x1)) → U9_GAGA(y1, .(x0, x1), U1_ag(member_in_ag(x1))) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))

(108) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(109) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U5_GAGA(z0, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(p(x2, x3), z3)) we obtained the following new rules [LPAR04]:

U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))

(110) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(111) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U5_GAGA(z0, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t(.(x3, z0), space, []), .(z2, z3)) we obtained the following new rules [LPAR04]:

U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x3, x4), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(x3, x4), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))

(112) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(113) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U9_GAGA(z1, .(p(x2, x3), z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(p(x2, x3), z3)) we obtained the following new rules [LPAR04]:

U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))

(114) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(115) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule U9_GAGA(z1, .(z2, z3), member_out_ag(p(x2, x3))) → TURING_IN_GAGA(t([], space, .(x3, z1)), .(z2, z3)) we obtained the following new rules [LPAR04]:

U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x3, x4), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(x3, x4), z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))

(116) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(117) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), member_out_ag(x0)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_3, y_4), x5)) → U3_GAGA(x0, x2, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))

(118) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_3, y_4), x5)) → U3_GAGA(x0, x2, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(119) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), member_out_ag(x0)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_3, y_4), x5)) → U7_GAGA(x0, x1, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))

(120) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_3, y_4), x5)) → U3_GAGA(x0, x2, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_3, y_4), x5)) → U7_GAGA(x0, x1, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(121) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), member_out_ag(z3)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_2, y_3), x4)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x4), member_out_ag(p(y_2, y_3)))

(122) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_3, y_4), x5)) → U3_GAGA(x0, x2, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_3, y_4), x5)) → U7_GAGA(x0, x1, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_2, y_3), x4)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x4), member_out_ag(p(y_2, y_3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(123) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(y_2, y_3), x3)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x3), member_out_ag(p(y_2, y_3)))

(124) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_3, y_4), x5)) → U3_GAGA(x0, x2, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_3, y_4), x5)) → U7_GAGA(x0, x1, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_2, y_3), x4)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x4), member_out_ag(p(y_2, y_3)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(y_2, y_3), x3)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x3), member_out_ag(p(y_2, y_3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(125) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), member_out_ag(z3)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], x0, .(x1, x2)), .(p(y_2, y_3), x4)) → U9_GAGA(.(x1, x2), .(p(y_2, y_3), x4), member_out_ag(p(y_2, y_3)))

(126) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_3, y_4), x5)) → U3_GAGA(x0, x2, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_3, y_4), x5)) → U7_GAGA(x0, x1, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_2, y_3), x4)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x4), member_out_ag(p(y_2, y_3)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(y_2, y_3), x3)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x3), member_out_ag(p(y_2, y_3)))
TURING_IN_GAGA(t([], x0, .(x1, x2)), .(p(y_2, y_3), x4)) → U9_GAGA(.(x1, x2), .(p(y_2, y_3), x4), member_out_ag(p(y_2, y_3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(127) ForwardInstantiation (EQUIVALENT transformation)

By forward instantiating [JAR06] the rule TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), member_out_ag(z1)) we obtained the following new rules [LPAR04]:

TURING_IN_GAGA(t([], space, .(x0, x1)), .(p(y_2, y_3), x3)) → U9_GAGA(.(x0, x1), .(p(y_2, y_3), x3), member_out_ag(p(y_2, y_3)))

(128) Obligation:

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

TURING_IN_GAGA(t(y0, y1, .(y2, y3)), .(x0, x1)) → U3_GAGA(y0, y2, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
TURING_IN_GAGA(t(.(y0, y1), y2, y3), .(x0, x1)) → U7_GAGA(y0, y1, y3, .(x0, x1), U1_ag(member_in_ag(x1)))
U3_GAGA(z0, z2, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(p(x4, x5), z5))
U3_GAGA(z0, z2, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(.(x5, z0), z2, z3), .(z4, z5))
U7_GAGA(z0, z1, z3, .(p(x4, x5), z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(p(x4, x5), z5))
U7_GAGA(z0, z1, z3, .(z4, z5), member_out_ag(p(x4, x5))) → TURING_IN_GAGA(t(z1, z0, .(x5, z3)), .(z4, z5))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t(.(z6, z0), z1, []), .(z3, z4)) → U5_GAGA(.(z6, z0), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t(.(z2, z0), space, []), .(p(z1, z2), z3)) → U5_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t(.(z4, z0), space, []), .(z1, z2)) → U5_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), member_out_ag(p(z1, z2)))
TURING_IN_GAGA(t([], z0, .(z4, z2)), .(p(z3, z4), z5)) → U9_GAGA(.(z4, z2), .(p(z3, z4), z5), U1_ag(member_in_ag(z5)))
TURING_IN_GAGA(t([], z0, .(z6, z2)), .(z3, z4)) → U9_GAGA(.(z6, z2), .(z3, z4), U1_ag(member_in_ag(z4)))
TURING_IN_GAGA(t([], space, .(z2, z0)), .(p(z1, z2), z3)) → U9_GAGA(.(z2, z0), .(p(z1, z2), z3), U1_ag(member_in_ag(z3)))
TURING_IN_GAGA(t([], space, .(z4, z0)), .(z1, z2)) → U9_GAGA(.(z4, z0), .(z1, z2), U1_ag(member_in_ag(z2)))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(z3, z0))) → TURING_IN_GAGA(t(.(z0, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t(.(x2, .(z0, z1)), space, []), .(p(x1, x2), z4))
U5_GAGA(.(z0, z1), .(p(z3, z0), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(p(z3, z0), z4))
U5_GAGA(.(z0, z1), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t(.(x4, .(z0, z1)), space, []), .(z3, z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(z3, z1))) → TURING_IN_GAGA(t([], space, .(z1, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(p(x1, x2), z4), member_out_ag(p(x1, x2))) → TURING_IN_GAGA(t([], space, .(x2, .(z1, z2))), .(p(x1, x2), z4))
U9_GAGA(.(z1, z2), .(p(z3, z1), z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(p(z3, z1), z4))
U9_GAGA(.(z1, z2), .(z3, z4), member_out_ag(p(x3, x4))) → TURING_IN_GAGA(t([], space, .(x4, .(z1, z2))), .(z3, z4))
TURING_IN_GAGA(t(x0, x1, .(x2, x3)), .(p(y_3, y_4), x5)) → U3_GAGA(x0, x2, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, x3), .(p(y_3, y_4), x5)) → U7_GAGA(x0, x1, x3, .(p(y_3, y_4), x5), member_out_ag(p(y_3, y_4)))
TURING_IN_GAGA(t(.(x0, x1), x2, []), .(p(y_2, y_3), x4)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x4), member_out_ag(p(y_2, y_3)))
TURING_IN_GAGA(t(.(x0, x1), space, []), .(p(y_2, y_3), x3)) → U5_GAGA(.(x0, x1), .(p(y_2, y_3), x3), member_out_ag(p(y_2, y_3)))
TURING_IN_GAGA(t([], x0, .(x1, x2)), .(p(y_2, y_3), x4)) → U9_GAGA(.(x1, x2), .(p(y_2, y_3), x4), member_out_ag(p(y_2, y_3)))
TURING_IN_GAGA(t([], space, .(x0, x1)), .(p(y_2, y_3), x3)) → U9_GAGA(.(x0, x1), .(p(y_2, y_3), x3), member_out_ag(p(y_2, y_3)))

The TRS R consists of the following rules:

member_in_ag(.(H, L)) → member_out_ag(H)
member_in_ag(.(H, L)) → U1_ag(member_in_ag(L))
U1_ag(member_out_ag(X)) → member_out_ag(X)

The set Q consists of the following terms:

member_in_ag(x0)
U1_ag(x0)

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

(129) NonTerminationProof (EQUIVALENT transformation)

We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

s = U5_GAGA(.(z0', z1'), .(p(z3', z0'), z4'), member_out_ag(p(z3', z0'))) evaluates to t =U5_GAGA(.(z0', .(z0', z1')), .(p(z3', z0'), z4'), member_out_ag(p(z3', z0')))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
  • Matcher: [z1' / .(z0', z1')]
  • Semiunifier: [ ]



Rewriting sequence

U5_GAGA(.(z0', z1'), .(p(z3', z0'), z4'), member_out_ag(p(z3', z0'))) → TURING_IN_GAGA(t(.(z0', .(z0', z1')), space, []), .(p(z3', z0'), z4'))
with rule U5_GAGA(.(z0'', z1''), .(p(z3'', z0''), z4''), member_out_ag(p(z3'', z0''))) → TURING_IN_GAGA(t(.(z0'', .(z0'', z1'')), space, []), .(p(z3'', z0''), z4'')) at position [] and matcher [z0'' / z0', z1'' / z1', z3'' / z3', z4'' / z4']

TURING_IN_GAGA(t(.(z0', .(z0', z1')), space, []), .(p(z3', z0'), z4')) → U5_GAGA(.(z0', .(z0', z1')), .(p(z3', z0'), z4'), member_out_ag(p(z3', z0')))
with rule TURING_IN_GAGA(t(.(z4, z0), z1, []), .(p(z3, z4), z5)) → U5_GAGA(.(z4, z0), .(p(z3, z4), z5), member_out_ag(p(z3, z4)))

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence


All these steps are and every following step will be a correct step w.r.t to Q.



(130) FALSE