(0) Obligation:
Clauses:
eq(t, t).
eq(f, f).
neq(t, f).
neq(f, t).
del(X1, [], []).
del(X, .(Y, YS), YS) :- eq(X, Y).
del(X, .(Y, YS), .(Y, ZS)) :- ','(neq(X, Y), del(X, YS, ZS)).
ge(t, t).
ge(t, f).
ge(f, f).
gt(t, f).
max([], f).
max(.(X, []), X).
max(.(X, .(Y, XS)), Z) :- ','(ge(X, Y), max(.(X, XS), Z)).
max(.(X, .(Y, XS)), Z) :- ','(gt(Y, X), max(.(Y, XS), Z)).
maxsort([], []).
maxsort(.(X, XS), .(Y, YS)) :- ','(max(.(X, XS), Y), ','(del(Y, .(X, XS), ZS), maxsort(ZS, YS))).
Queries:
maxsort(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:
maxsort_in: (b,f)
max_in: (b,f)
del_in: (b,b,f)
Transforming
Prolog into the following
Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x2,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x3,
x5)
Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog
(2) Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x2,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x3,
x5)
(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:
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → U8_GA(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → MAX_IN_GA(.(X, XS), Y)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U4_GA(X, Y, XS, Z, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS)), Z) → GE_IN_GG(X, Y)
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_GA(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS), Z)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U6_GA(X, Y, XS, Z, gt_in_gg(Y, X))
MAX_IN_GA(.(X, .(Y, XS)), Z) → GT_IN_GG(Y, X)
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_GA(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS), Z)
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → DEL_IN_GGA(Y, .(X, XS), ZS)
DEL_IN_GGA(X, .(Y, YS), YS) → U1_GGA(X, Y, YS, eq_in_gg(X, Y))
DEL_IN_GGA(X, .(Y, YS), YS) → EQ_IN_GG(X, Y)
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → U2_GGA(X, Y, YS, ZS, neq_in_gg(X, Y))
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → NEQ_IN_GG(X, Y)
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_GGA(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS, ZS)
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_GA(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS, YS)
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x2,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x3,
x5)
MAXSORT_IN_GA(
x1,
x2) =
MAXSORT_IN_GA(
x1)
U8_GA(
x1,
x2,
x3,
x4,
x5) =
U8_GA(
x1,
x2,
x5)
MAX_IN_GA(
x1,
x2) =
MAX_IN_GA(
x1)
U4_GA(
x1,
x2,
x3,
x4,
x5) =
U4_GA(
x1,
x3,
x5)
GE_IN_GG(
x1,
x2) =
GE_IN_GG(
x1,
x2)
U5_GA(
x1,
x2,
x3,
x4,
x5) =
U5_GA(
x5)
U6_GA(
x1,
x2,
x3,
x4,
x5) =
U6_GA(
x2,
x3,
x5)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
U7_GA(
x1,
x2,
x3,
x4,
x5) =
U7_GA(
x5)
U9_GA(
x1,
x2,
x3,
x4,
x5) =
U9_GA(
x3,
x5)
DEL_IN_GGA(
x1,
x2,
x3) =
DEL_IN_GGA(
x1,
x2)
U1_GGA(
x1,
x2,
x3,
x4) =
U1_GGA(
x3,
x4)
EQ_IN_GG(
x1,
x2) =
EQ_IN_GG(
x1,
x2)
U2_GGA(
x1,
x2,
x3,
x4,
x5) =
U2_GGA(
x1,
x2,
x3,
x5)
NEQ_IN_GG(
x1,
x2) =
NEQ_IN_GG(
x1,
x2)
U3_GGA(
x1,
x2,
x3,
x4,
x5) =
U3_GGA(
x2,
x5)
U10_GA(
x1,
x2,
x3,
x4,
x5) =
U10_GA(
x3,
x5)
We have to consider all (P,R,Pi)-chains
(4) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → U8_GA(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → MAX_IN_GA(.(X, XS), Y)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U4_GA(X, Y, XS, Z, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS)), Z) → GE_IN_GG(X, Y)
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_GA(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS), Z)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U6_GA(X, Y, XS, Z, gt_in_gg(Y, X))
MAX_IN_GA(.(X, .(Y, XS)), Z) → GT_IN_GG(Y, X)
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_GA(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS), Z)
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → DEL_IN_GGA(Y, .(X, XS), ZS)
DEL_IN_GGA(X, .(Y, YS), YS) → U1_GGA(X, Y, YS, eq_in_gg(X, Y))
DEL_IN_GGA(X, .(Y, YS), YS) → EQ_IN_GG(X, Y)
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → U2_GGA(X, Y, YS, ZS, neq_in_gg(X, Y))
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → NEQ_IN_GG(X, Y)
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_GGA(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS, ZS)
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_GA(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS, YS)
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x2,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x3,
x5)
MAXSORT_IN_GA(
x1,
x2) =
MAXSORT_IN_GA(
x1)
U8_GA(
x1,
x2,
x3,
x4,
x5) =
U8_GA(
x1,
x2,
x5)
MAX_IN_GA(
x1,
x2) =
MAX_IN_GA(
x1)
U4_GA(
x1,
x2,
x3,
x4,
x5) =
U4_GA(
x1,
x3,
x5)
GE_IN_GG(
x1,
x2) =
GE_IN_GG(
x1,
x2)
U5_GA(
x1,
x2,
x3,
x4,
x5) =
U5_GA(
x5)
U6_GA(
x1,
x2,
x3,
x4,
x5) =
U6_GA(
x2,
x3,
x5)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
U7_GA(
x1,
x2,
x3,
x4,
x5) =
U7_GA(
x5)
U9_GA(
x1,
x2,
x3,
x4,
x5) =
U9_GA(
x3,
x5)
DEL_IN_GGA(
x1,
x2,
x3) =
DEL_IN_GGA(
x1,
x2)
U1_GGA(
x1,
x2,
x3,
x4) =
U1_GGA(
x3,
x4)
EQ_IN_GG(
x1,
x2) =
EQ_IN_GG(
x1,
x2)
U2_GGA(
x1,
x2,
x3,
x4,
x5) =
U2_GGA(
x1,
x2,
x3,
x5)
NEQ_IN_GG(
x1,
x2) =
NEQ_IN_GG(
x1,
x2)
U3_GGA(
x1,
x2,
x3,
x4,
x5) =
U3_GGA(
x2,
x5)
U10_GA(
x1,
x2,
x3,
x4,
x5) =
U10_GA(
x3,
x5)
We have to consider all (P,R,Pi)-chains
(5) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LOPSTR] contains 3 SCCs with 11 less nodes.
(6) Complex Obligation (AND)
(7) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → U2_GGA(X, Y, YS, ZS, neq_in_gg(X, Y))
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS, ZS)
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x2,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x3,
x5)
DEL_IN_GGA(
x1,
x2,
x3) =
DEL_IN_GGA(
x1,
x2)
U2_GGA(
x1,
x2,
x3,
x4,
x5) =
U2_GGA(
x1,
x2,
x3,
x5)
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:
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → U2_GGA(X, Y, YS, ZS, neq_in_gg(X, Y))
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS, ZS)
The TRS R consists of the following rules:
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
t =
t
f =
f
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
DEL_IN_GGA(
x1,
x2,
x3) =
DEL_IN_GGA(
x1,
x2)
U2_GGA(
x1,
x2,
x3,
x4,
x5) =
U2_GGA(
x1,
x2,
x3,
x5)
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:
DEL_IN_GGA(X, .(Y, YS)) → U2_GGA(X, Y, YS, neq_in_gg(X, Y))
U2_GGA(X, Y, YS, neq_out_gg) → DEL_IN_GGA(X, YS)
The TRS R consists of the following rules:
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
The set Q consists of the following terms:
neq_in_gg(x0, x1)
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:
- U2_GGA(X, Y, YS, neq_out_gg) → DEL_IN_GGA(X, YS)
The graph contains the following edges 1 >= 1, 3 >= 2
- DEL_IN_GGA(X, .(Y, YS)) → U2_GGA(X, Y, YS, neq_in_gg(X, Y))
The graph contains the following edges 1 >= 1, 2 > 2, 2 > 3
(13) TRUE
(14) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS), Z)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U4_GA(X, Y, XS, Z, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS)), Z) → U6_GA(X, Y, XS, Z, gt_in_gg(Y, X))
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS), Z)
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x2,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x3,
x5)
MAX_IN_GA(
x1,
x2) =
MAX_IN_GA(
x1)
U4_GA(
x1,
x2,
x3,
x4,
x5) =
U4_GA(
x1,
x3,
x5)
U6_GA(
x1,
x2,
x3,
x4,
x5) =
U6_GA(
x2,
x3,
x5)
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:
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS), Z)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U4_GA(X, Y, XS, Z, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS)), Z) → U6_GA(X, Y, XS, Z, gt_in_gg(Y, X))
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS), Z)
The TRS R consists of the following rules:
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
gt_in_gg(t, f) → gt_out_gg(t, f)
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
MAX_IN_GA(
x1,
x2) =
MAX_IN_GA(
x1)
U4_GA(
x1,
x2,
x3,
x4,
x5) =
U4_GA(
x1,
x3,
x5)
U6_GA(
x1,
x2,
x3,
x4,
x5) =
U6_GA(
x2,
x3,
x5)
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:
U4_GA(X, XS, ge_out_gg) → MAX_IN_GA(.(X, XS))
MAX_IN_GA(.(X, .(Y, XS))) → U4_GA(X, XS, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS))) → U6_GA(Y, XS, gt_in_gg(Y, X))
U6_GA(Y, XS, gt_out_gg) → MAX_IN_GA(.(Y, XS))
The TRS R consists of the following rules:
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
gt_in_gg(t, f) → gt_out_gg
The set Q consists of the following terms:
ge_in_gg(x0, x1)
gt_in_gg(x0, x1)
We have to consider all (P,Q,R)-chains.
(19) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
U4_GA(X, XS, ge_out_gg) → MAX_IN_GA(.(X, XS))
MAX_IN_GA(.(X, .(Y, XS))) → U6_GA(Y, XS, gt_in_gg(Y, X))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(.(x1, x2)) = 1 + x2
POL(MAX_IN_GA(x1)) = x1
POL(U4_GA(x1, x2, x3)) = 1 + x2 + x3
POL(U6_GA(x1, x2, x3)) = 1 + x2
POL(f) = 0
POL(ge_in_gg(x1, x2)) = 1
POL(ge_out_gg) = 1
POL(gt_in_gg(x1, x2)) = 0
POL(gt_out_gg) = 0
POL(t) = 0
The following usable rules [FROCOS05] were oriented:
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
(20) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAX_IN_GA(.(X, .(Y, XS))) → U4_GA(X, XS, ge_in_gg(X, Y))
U6_GA(Y, XS, gt_out_gg) → MAX_IN_GA(.(Y, XS))
The TRS R consists of the following rules:
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
gt_in_gg(t, f) → gt_out_gg
The set Q consists of the following terms:
ge_in_gg(x0, x1)
gt_in_gg(x0, x1)
We have to consider all (P,Q,R)-chains.
(21) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 2 less nodes.
(22) TRUE
(23) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS, YS)
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → U8_GA(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x2,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x3,
x5)
MAXSORT_IN_GA(
x1,
x2) =
MAXSORT_IN_GA(
x1)
U8_GA(
x1,
x2,
x3,
x4,
x5) =
U8_GA(
x1,
x2,
x5)
U9_GA(
x1,
x2,
x3,
x4,
x5) =
U9_GA(
x3,
x5)
We have to consider all (P,R,Pi)-chains
(24) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(25) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS, YS)
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → U8_GA(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
The argument filtering Pi contains the following mapping:
[] =
[]
.(
x1,
x2) =
.(
x1,
x2)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x2,
x5)
MAXSORT_IN_GA(
x1,
x2) =
MAXSORT_IN_GA(
x1)
U8_GA(
x1,
x2,
x3,
x4,
x5) =
U8_GA(
x1,
x2,
x5)
U9_GA(
x1,
x2,
x3,
x4,
x5) =
U9_GA(
x3,
x5)
We have to consider all (P,R,Pi)-chains
(26) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(27) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(X, XS, max_out_ga(Y)) → U9_GA(Y, del_in_gga(Y, .(X, XS)))
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(X, XS)) → U8_GA(X, XS, max_in_ga(.(X, XS)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(28) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
U8_GA(
X,
XS,
max_out_ga(
Y)) →
U9_GA(
Y,
del_in_gga(
Y,
.(
X,
XS))) at position [1] we obtained the following new rules [LPAR04]:
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U1_gga(x2, eq_in_gg(x0, x1)))
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
(29) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(X, XS)) → U8_GA(X, XS, max_in_ga(.(X, XS)))
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U1_gga(x2, eq_in_gg(x0, x1)))
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(30) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
MAXSORT_IN_GA(
.(
X,
XS)) →
U8_GA(
X,
XS,
max_in_ga(
.(
X,
XS))) at position [2] we obtained the following new rules [LPAR04]:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x1, x2, gt_in_gg(x1, x0)))
(31) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U1_gga(x2, eq_in_gg(x0, x1)))
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x1, x2, gt_in_gg(x1, x0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(32) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
U8_GA(
x1,
x2,
max_out_ga(
x0)) →
U9_GA(
x0,
U1_gga(
x2,
eq_in_gg(
x0,
x1))) at position [1,1] we obtained the following new rules [LPAR04]:
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, U1_gga(y1, eq_out_gg))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, U1_gga(y1, eq_out_gg))
(33) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x1, x2, gt_in_gg(x1, x0)))
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, U1_gga(y1, eq_out_gg))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, U1_gga(y1, eq_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(34) Rewriting (EQUIVALENT transformation)
By rewriting [LPAR04] the rule
U8_GA(
t,
y1,
max_out_ga(
t)) →
U9_GA(
t,
U1_gga(
y1,
eq_out_gg)) at position [1] we obtained the following new rules [LPAR04]:
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, del_out_gga(y1))
(35) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x1, x2, gt_in_gg(x1, x0)))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, U1_gga(y1, eq_out_gg))
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, del_out_gga(y1))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(36) Rewriting (EQUIVALENT transformation)
By rewriting [LPAR04] the rule
U8_GA(
f,
y1,
max_out_ga(
f)) →
U9_GA(
f,
U1_gga(
y1,
eq_out_gg)) at position [1] we obtained the following new rules [LPAR04]:
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, del_out_gga(y1))
(37) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
U8_GA(x1, x2, max_out_ga(x0)) → U9_GA(x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x1, x2, gt_in_gg(x1, x0)))
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, del_out_gga(y1))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(38) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
U8_GA(
x1,
x2,
max_out_ga(
x0)) →
U9_GA(
x0,
U2_gga(
x0,
x1,
x2,
neq_in_gg(
x0,
x1))) at position [1,3] we obtained the following new rules [LPAR04]:
U8_GA(f, y1, max_out_ga(t)) → U9_GA(t, U2_gga(t, f, y1, neq_out_gg))
U8_GA(t, y1, max_out_ga(f)) → U9_GA(f, U2_gga(f, t, y1, neq_out_gg))
(39) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x1, x2, gt_in_gg(x1, x0)))
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(t)) → U9_GA(t, U2_gga(t, f, y1, neq_out_gg))
U8_GA(t, y1, max_out_ga(f)) → U9_GA(f, U2_gga(f, t, y1, neq_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(40) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
MAXSORT_IN_GA(
.(
x0,
.(
x1,
x2))) →
U8_GA(
x0,
.(
x1,
x2),
U4_ga(
x0,
x2,
ge_in_gg(
x0,
x1))) at position [2,2] we obtained the following new rules [LPAR04]:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
(41) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x1, x2, gt_in_gg(x1, x0)))
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(t)) → U9_GA(t, U2_gga(t, f, y1, neq_out_gg))
U8_GA(t, y1, max_out_ga(f)) → U9_GA(f, U2_gga(f, t, y1, neq_out_gg))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(42) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
MAXSORT_IN_GA(
.(
x0,
.(
x1,
x2))) →
U8_GA(
x0,
.(
x1,
x2),
U6_ga(
x1,
x2,
gt_in_gg(
x1,
x0))) at position [2,2] we obtained the following new rules [LPAR04]:
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
(43) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(Y, del_out_gga(ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(t)) → U9_GA(t, U2_gga(t, f, y1, neq_out_gg))
U8_GA(t, y1, max_out_ga(f)) → U9_GA(f, U2_gga(f, t, y1, neq_out_gg))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(44) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U9_GA(
Y,
del_out_gga(
ZS)) →
MAXSORT_IN_GA(
ZS) we obtained the following new rules [LPAR04]:
U9_GA(t, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
(45) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
U8_GA(t, y1, max_out_ga(t)) → U9_GA(t, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(t)) → U9_GA(t, U2_gga(t, f, y1, neq_out_gg))
U8_GA(t, y1, max_out_ga(f)) → U9_GA(f, U2_gga(f, t, y1, neq_out_gg))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U9_GA(t, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(46) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U8_GA(
t,
y1,
max_out_ga(
t)) →
U9_GA(
t,
del_out_gga(
y1)) we obtained the following new rules [LPAR04]:
U8_GA(t, [], max_out_ga(t)) → U9_GA(t, del_out_gga([]))
U8_GA(t, .(t, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
(47) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
U8_GA(f, y1, max_out_ga(f)) → U9_GA(f, del_out_gga(y1))
U8_GA(f, y1, max_out_ga(t)) → U9_GA(t, U2_gga(t, f, y1, neq_out_gg))
U8_GA(t, y1, max_out_ga(f)) → U9_GA(f, U2_gga(f, t, y1, neq_out_gg))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U9_GA(t, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U8_GA(t, [], max_out_ga(t)) → U9_GA(t, del_out_gga([]))
U8_GA(t, .(t, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(48) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U8_GA(
f,
y1,
max_out_ga(
f)) →
U9_GA(
f,
del_out_gga(
y1)) we obtained the following new rules [LPAR04]:
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
(49) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
U8_GA(f, y1, max_out_ga(t)) → U9_GA(t, U2_gga(t, f, y1, neq_out_gg))
U8_GA(t, y1, max_out_ga(f)) → U9_GA(f, U2_gga(f, t, y1, neq_out_gg))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U9_GA(t, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U8_GA(t, [], max_out_ga(t)) → U9_GA(t, del_out_gga([]))
U8_GA(t, .(t, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(50) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U8_GA(
f,
y1,
max_out_ga(
t)) →
U9_GA(
t,
U2_gga(
t,
f,
y1,
neq_out_gg)) we obtained the following new rules [LPAR04]:
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
(51) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
U8_GA(t, y1, max_out_ga(f)) → U9_GA(f, U2_gga(f, t, y1, neq_out_gg))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U9_GA(t, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U8_GA(t, [], max_out_ga(t)) → U9_GA(t, del_out_gga([]))
U8_GA(t, .(t, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(52) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U8_GA(
t,
y1,
max_out_ga(
f)) →
U9_GA(
f,
U2_gga(
f,
t,
y1,
neq_out_gg)) we obtained the following new rules [LPAR04]:
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
(53) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(x0))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U9_GA(t, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U8_GA(t, [], max_out_ga(t)) → U9_GA(t, del_out_gga([]))
U8_GA(t, .(t, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(54) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
MAXSORT_IN_GA(
.(
x0,
[])) →
U8_GA(
x0,
[],
max_out_ga(
x0)) we obtained the following new rules [LPAR04]:
MAXSORT_IN_GA(.(t, [])) → U8_GA(t, [], max_out_ga(t))
MAXSORT_IN_GA(.(f, [])) → U8_GA(f, [], max_out_ga(f))
(55) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U9_GA(t, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U8_GA(t, [], max_out_ga(t)) → U9_GA(t, del_out_gga([]))
U8_GA(t, .(t, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
MAXSORT_IN_GA(.(t, [])) → U8_GA(t, [], max_out_ga(t))
MAXSORT_IN_GA(.(f, [])) → U8_GA(f, [], max_out_ga(f))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(56) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
t,
del_out_gga(
z0)) →
MAXSORT_IN_GA(
z0) we obtained the following new rules [LPAR04]:
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, []))) → MAXSORT_IN_GA(.(t, []))
U9_GA(t, del_out_gga(.(f, []))) → MAXSORT_IN_GA(.(f, []))
(57) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
U8_GA(t, [], max_out_ga(t)) → U9_GA(t, del_out_gga([]))
U8_GA(t, .(t, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
MAXSORT_IN_GA(.(t, [])) → U8_GA(t, [], max_out_ga(t))
MAXSORT_IN_GA(.(f, [])) → U8_GA(f, [], max_out_ga(f))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, []))) → MAXSORT_IN_GA(.(t, []))
U9_GA(t, del_out_gga(.(f, []))) → MAXSORT_IN_GA(.(f, []))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(58) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.
(59) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(t, .(t, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, z0)))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(f, []))) → MAXSORT_IN_GA(.(f, []))
MAXSORT_IN_GA(.(f, [])) → U8_GA(f, [], max_out_ga(f))
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(60) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U8_GA(
t,
.(
t,
z0),
max_out_ga(
t)) →
U9_GA(
t,
del_out_gga(
.(
t,
z0))) we obtained the following new rules [LPAR04]:
U8_GA(t, .(t, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(f, y_0))))
(61) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(z0)) → MAXSORT_IN_GA(z0)
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(f, []))) → MAXSORT_IN_GA(.(f, []))
MAXSORT_IN_GA(.(f, [])) → U8_GA(f, [], max_out_ga(f))
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(f, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(62) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
f,
del_out_gga(
z0)) →
MAXSORT_IN_GA(
z0) we obtained the following new rules [LPAR04]:
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(f, del_out_gga(.(f, []))) → MAXSORT_IN_GA(.(f, []))
(63) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(f, []))) → MAXSORT_IN_GA(.(f, []))
MAXSORT_IN_GA(.(f, [])) → U8_GA(f, [], max_out_ga(f))
U8_GA(f, [], max_out_ga(f)) → U9_GA(f, del_out_gga([]))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(f, y_0))))
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(f, del_out_gga(.(f, []))) → MAXSORT_IN_GA(.(f, []))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(64) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
(65) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(f, z0), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, z0)))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(f, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(66) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U8_GA(
t,
.(
f,
z0),
max_out_ga(
t)) →
U9_GA(
t,
del_out_gga(
.(
f,
z0))) we obtained the following new rules [LPAR04]:
U8_GA(t, .(f, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(t, y_0))))
(67) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U8_GA(f, .(f, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, z0)))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(f, y_0))))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(t, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(68) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U8_GA(
f,
.(
f,
z0),
max_out_ga(
f)) →
U9_GA(
f,
del_out_gga(
.(
f,
z0))) we obtained the following new rules [LPAR04]:
U8_GA(f, .(f, .(f, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, .(t, y_0))))
(69) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U8_GA(f, .(t, z0), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(f, y_0))))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(t, y_0))))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, .(t, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(70) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U8_GA(
f,
.(
t,
z0),
max_out_ga(
f)) →
U9_GA(
f,
del_out_gga(
.(
t,
z0))) we obtained the following new rules [LPAR04]:
U8_GA(f, .(t, .(t, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, .(t, y_0))))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, .(f, y_0))))
(71) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(f, y_0))))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(t, y_0))))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, .(t, y_0))))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, .(t, y_0))))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, .(f, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(72) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
U8_GA(t, .(t, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(t, .(f, y_0))))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(t)) → U9_GA(t, del_out_gga(.(f, .(t, y_0))))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(f, .(t, y_0))))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, .(t, y_0))))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(f)) → U9_GA(f, del_out_gga(.(t, .(f, y_0))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(.(x1, x2)) = 1 + x2
POL(MAXSORT_IN_GA(x1)) = x1
POL(U1_gga(x1, x2)) = x1
POL(U2_gga(x1, x2, x3, x4)) = 1 + x3
POL(U3_gga(x1, x2)) = 1 + x2
POL(U4_ga(x1, x2, x3)) = 0
POL(U5_ga(x1)) = 0
POL(U6_ga(x1, x2, x3)) = 0
POL(U7_ga(x1)) = 0
POL(U8_GA(x1, x2, x3)) = x1 + x2
POL(U9_GA(x1, x2)) = x2
POL([]) = 0
POL(del_in_gga(x1, x2)) = x2
POL(del_out_gga(x1)) = x1
POL(eq_in_gg(x1, x2)) = x1 + x2
POL(eq_out_gg) = 0
POL(f) = 1
POL(ge_in_gg(x1, x2)) = 0
POL(ge_out_gg) = 0
POL(gt_in_gg(x1, x2)) = 0
POL(gt_out_gg) = 0
POL(max_in_ga(x1)) = 0
POL(max_out_ga(x1)) = 0
POL(neq_in_gg(x1, x2)) = 1
POL(neq_out_gg) = 0
POL(t) = 1
The following usable rules [FROCOS05] were oriented:
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X1, []) → del_out_gga([])
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
(73) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U8_GA(f, .(t, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(t, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(74) Induction-Processor (SOUND transformation)
This DP could be deleted by the Induction-Processor:U8_GA(
f,
.(
t,
z0'),
max_out_ga(
t)) →
U9_GA(
t,
U2_gga(
t,
f,
.(
t,
z0'),
neq_out_gg))
This order was computed:Polynomial interpretation [POLO]:
POL(.(x1, x2)) = x1 + x2
POL(MAXSORT_IN_GA(x1)) = x1
POL(U1_gga(x1, x2)) = x1 + x2
POL(U2_gga(x1, x2, x3, x4)) = x2 + x3
POL(U3_gga(x1, x2)) = x1 + x2
POL(U4_ga(x1, x2, x3)) = 0
POL(U5_ga(x1)) = 0
POL(U6_ga(x1, x2, x3)) = 0
POL(U7_ga(x1)) = 0
POL(U8_GA(x1, x2, x3)) = x1 + x2
POL(U9_GA(x1, x2)) = x2
POL([]) = 0
POL(del_in_gga(x1, x2)) = x2
POL(del_out_gga(x1)) = x1
POL(eq_in_gg(x1, x2)) = x2
POL(eq_out_gg) = 0
POL(f) = 0
POL(ge_in_gg(x1, x2)) = 1 + x2
POL(ge_out_gg) = 1
POL(gt_in_gg(x1, x2)) = 0
POL(gt_out_gg) = 0
POL(max_in_ga(x1)) = 0
POL(max_out_ga(x1)) = 0
POL(neq_in_gg(x1, x2)) = x1
POL(neq_out_gg) = 0
POL(t) = 1
POL(witness_sort[a53]) = 0
POL(witness_sort[a67]) = 0
At least one of these decreasing rules is always used after the deleted DP:eq_in_gg(
t,
t) →
eq_out_ggThe following formula is valid:z0':sort[a2].
U2gga'(
t,
f,
.(
t,
z0' ),
neqoutgg)=
trueThe transformed set:U2_gga'(
X,
Y,
YS,
neq_out_gg) →
del_in_gga'(
X,
YS)
del_in_gga'(
X'',
.(
Y1,
YS')) →
eq_in_gg'(
X'',
Y1)
del_in_gga'(
X9,
.(
Y9,
YS4)) →
U2_gga'(
X9,
Y9,
YS4,
neq_in_gg(
X9,
Y9))
eq_in_gg'(
t,
t) →
trueeq_in_gg'(
f,
f) →
falsedel_in_gga'(
X158,
[]) →
falseeq_in_gg'(
f,
t) →
falseeq_in_gg'(
t,
f) →
falseU2_gga(
X,
Y,
YS,
neq_out_gg) →
U3_gga(
Y,
del_in_gga(
X,
YS))
del_in_gga(
X'',
.(
Y1,
YS')) →
U1_gga(
YS',
eq_in_gg(
X'',
Y1))
del_in_gga(
X9,
.(
Y9,
YS4)) →
U2_gga(
X9,
Y9,
YS4,
neq_in_gg(
X9,
Y9))
max_in_ga(
.(
X17,
[])) →
max_out_ga(
X17)
max_in_ga(
.(
X25,
.(
Y24,
XS12))) →
U4_ga(
X25,
XS12,
ge_in_gg(
X25,
Y24))
max_in_ga(
.(
X33,
.(
Y32,
XS17))) →
U6_ga(
Y32,
XS17,
gt_in_gg(
Y32,
X33))
U1_gga(
YS21,
eq_out_gg) →
del_out_gga(
YS21)
U4_ga(
X49,
XS26,
ge_out_gg) →
U5_ga(
max_in_ga(
.(
X49,
XS26)))
U6_ga(
Y55,
XS31,
gt_out_gg) →
U7_ga(
max_in_ga(
.(
Y55,
XS31)))
eq_in_gg(
t,
t) →
eq_out_ggeq_in_gg(
f,
f) →
eq_out_ggneq_in_gg(
t,
f) →
neq_out_ggneq_in_gg(
f,
t) →
neq_out_ggU3_gga(
Y91,
del_out_gga(
ZS11)) →
del_out_gga(
.(
Y91,
ZS11))
ge_in_gg(
t,
t) →
ge_out_ggge_in_gg(
t,
f) →
ge_out_ggge_in_gg(
f,
f) →
ge_out_ggU5_ga(
max_out_ga(
Z32)) →
max_out_ga(
Z32)
gt_in_gg(
t,
f) →
gt_out_ggU7_ga(
max_out_ga(
Z37)) →
max_out_ga(
Z37)
del_in_gga(
X158,
[]) →
del_out_gga(
[])
max_in_ga(
[]) →
witness_sort[a67]eq_in_gg(
f,
t) →
eq_out_ggeq_in_gg(
t,
f) →
eq_out_ggneq_in_gg(
f,
f) →
neq_out_ggneq_in_gg(
t,
t) →
neq_out_ggU3_gga(
x0,
witness_sort[a53]) →
witness_sort[a53]ge_in_gg(
f,
t) →
ge_out_ggU5_ga(
witness_sort[a67]) →
witness_sort[a67]gt_in_gg(
f,
x1) →
gt_out_gggt_in_gg(
t,
t) →
gt_out_ggU7_ga(
witness_sort[a67]) →
witness_sort[a67]equal_bool(
true,
false) →
falseequal_bool(
false,
true) →
falseequal_bool(
true,
true) →
trueequal_bool(
false,
false) →
trueand(
true,
x) →
xand(
false,
x) →
falseor(
true,
x) →
trueor(
false,
x) →
xnot(
false) →
truenot(
true) →
falseisa_true(
true) →
trueisa_true(
false) →
falseisa_false(
true) →
falseisa_false(
false) →
trueequal_sort[a2](
[],
[]) →
trueequal_sort[a2](
[],
.(
x0,
x1)) →
falseequal_sort[a2](
.(
x0,
x1),
[]) →
falseequal_sort[a2](
.(
x0,
x1),
.(
x2,
x3)) →
and(
equal_sort[a2](
x0,
x2),
equal_sort[a2](
x1,
x3))
equal_sort[a67](
max_out_ga(
x0),
max_out_ga(
x1)) →
equal_sort[a67](
x0,
x1)
equal_sort[a67](
max_out_ga(
x0),
witness_sort[a67]) →
falseequal_sort[a67](
witness_sort[a67],
max_out_ga(
x0)) →
falseequal_sort[a67](
witness_sort[a67],
witness_sort[a67]) →
trueequal_sort[a0](
f,
f) →
trueequal_sort[a0](
f,
t) →
falseequal_sort[a0](
t,
f) →
falseequal_sort[a0](
t,
t) →
trueequal_sort[a47](
neq_out_gg,
neq_out_gg) →
trueequal_sort[a77](
ge_out_gg,
ge_out_gg) →
trueequal_sort[a84](
gt_out_gg,
gt_out_gg) →
trueequal_sort[a97](
witness_sort[a97],
witness_sort[a97]) →
trueequal_sort[a53](
del_out_gga(
x0),
del_out_gga(
x1)) →
equal_sort[a53](
x0,
x1)
equal_sort[a53](
del_out_gga(
x0),
witness_sort[a53]) →
falseequal_sort[a53](
witness_sort[a53],
del_out_gga(
x0)) →
falseequal_sort[a53](
witness_sort[a53],
witness_sort[a53]) →
trueequal_sort[a62](
eq_out_gg,
eq_out_gg) →
true
(75) Complex Obligation (AND)
(76) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(t, y2, gt_out_gg))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(77) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.
(78) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(t, .(t, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(t, z0), neq_out_gg))
U9_GA(f, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, y2, ge_out_gg))
U9_GA(f, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, y2, ge_out_gg))
U8_GA(t, .(f, z0), max_out_ga(f)) → U9_GA(f, U2_gga(f, t, .(f, z0), neq_out_gg))
U9_GA(f, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, y2, ge_out_gg))
U8_GA(f, .(f, z0), max_out_ga(t)) → U9_GA(t, U2_gga(t, f, .(f, z0), neq_out_gg))
U9_GA(t, del_out_gga(.(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, del_out_gga(.(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, del_out_gga(.(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(Y, XS, gt_in_gg(Y, X))
U1_gga(YS, eq_out_gg) → del_out_gga(YS)
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
U4_ga(X, XS, ge_out_gg) → U5_ga(max_in_ga(.(X, XS)))
U6_ga(Y, XS, gt_out_gg) → U7_ga(max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y, del_out_gga(ZS)) → del_out_gga(.(Y, ZS))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z)) → max_out_ga(Z)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z)) → max_out_ga(Z)
del_in_gga(X1, []) → del_out_gga([])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
U6_ga(x0, x1, x2)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1)
ge_in_gg(x0, x1)
U5_ga(x0)
gt_in_gg(x0, x1)
U7_ga(x0)
We have to consider all (P,Q,R)-chains.
(79) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
U2_gga'(X, Y, YS, neq_out_gg) → del_in_gga'(X, YS)
del_in_gga'(X'', .(Y1, YS')) → eq_in_gg'(X'', Y1)
del_in_gga'(X9, .(Y9, YS4)) → U2_gga'(X9, Y9, YS4, neq_in_gg(X9, Y9))
eq_in_gg'(t, t) → true
eq_in_gg'(f, f) → false
del_in_gga'(X158, []) → false
eq_in_gg'(f, t) → false
eq_in_gg'(t, f) → false
U2_gga(X, Y, YS, neq_out_gg) → U3_gga(Y, del_in_gga(X, YS))
del_in_gga(X'', .(Y1, YS')) → U1_gga(YS', eq_in_gg(X'', Y1))
del_in_gga(X9, .(Y9, YS4)) → U2_gga(X9, Y9, YS4, neq_in_gg(X9, Y9))
max_in_ga(.(X17, [])) → max_out_ga(X17)
max_in_ga(.(X25, .(Y24, XS12))) → U4_ga(X25, XS12, ge_in_gg(X25, Y24))
max_in_ga(.(X33, .(Y32, XS17))) → U6_ga(Y32, XS17, gt_in_gg(Y32, X33))
U1_gga(YS21, eq_out_gg) → del_out_gga(YS21)
U4_ga(X49, XS26, ge_out_gg) → U5_ga(max_in_ga(.(X49, XS26)))
U6_ga(Y55, XS31, gt_out_gg) → U7_ga(max_in_ga(.(Y55, XS31)))
eq_in_gg(t, t) → eq_out_gg
eq_in_gg(f, f) → eq_out_gg
neq_in_gg(t, f) → neq_out_gg
neq_in_gg(f, t) → neq_out_gg
U3_gga(Y91, del_out_gga(ZS11)) → del_out_gga(.(Y91, ZS11))
ge_in_gg(t, t) → ge_out_gg
ge_in_gg(t, f) → ge_out_gg
ge_in_gg(f, f) → ge_out_gg
U5_ga(max_out_ga(Z32)) → max_out_ga(Z32)
gt_in_gg(t, f) → gt_out_gg
U7_ga(max_out_ga(Z37)) → max_out_ga(Z37)
del_in_gga(X158, []) → del_out_gga([])
max_in_ga([]) → witness_sort[a67]
eq_in_gg(f, t) → eq_out_gg
eq_in_gg(t, f) → eq_out_gg
neq_in_gg(f, f) → neq_out_gg
neq_in_gg(t, t) → neq_out_gg
U3_gga(x0, witness_sort[a53]) → witness_sort[a53]
ge_in_gg(f, t) → ge_out_gg
U5_ga(witness_sort[a67]) → witness_sort[a67]
gt_in_gg(f, x1) → gt_out_gg
gt_in_gg(t, t) → gt_out_gg
U7_ga(witness_sort[a67]) → witness_sort[a67]
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a2]([], []) → true
equal_sort[a2]([], .(x0, x1)) → false
equal_sort[a2](.(x0, x1), []) → false
equal_sort[a2](.(x0, x1), .(x2, x3)) → and(equal_sort[a2](x0, x2), equal_sort[a2](x1, x3))
equal_sort[a67](max_out_ga(x0), max_out_ga(x1)) → equal_sort[a67](x0, x1)
equal_sort[a67](max_out_ga(x0), witness_sort[a67]) → false
equal_sort[a67](witness_sort[a67], max_out_ga(x0)) → false
equal_sort[a67](witness_sort[a67], witness_sort[a67]) → true
equal_sort[a0](f, f) → true
equal_sort[a0](f, t) → false
equal_sort[a0](t, f) → false
equal_sort[a0](t, t) → true
equal_sort[a47](neq_out_gg, neq_out_gg) → true
equal_sort[a77](ge_out_gg, ge_out_gg) → true
equal_sort[a84](gt_out_gg, gt_out_gg) → true
equal_sort[a97](witness_sort[a97], witness_sort[a97]) → true
equal_sort[a53](del_out_gga(x0), del_out_gga(x1)) → equal_sort[a53](x0, x1)
equal_sort[a53](del_out_gga(x0), witness_sort[a53]) → false
equal_sort[a53](witness_sort[a53], del_out_gga(x0)) → false
equal_sort[a53](witness_sort[a53], witness_sort[a53]) → true
equal_sort[a62](eq_out_gg, eq_out_gg) → true
Q is empty.
(80) PrologToPiTRSProof (SOUND transformation)
We use the technique of [LOPSTR]. With regard to the inferred argument filtering the predicates were used in the following modes:
maxsort_in: (b,f)
max_in: (b,f)
del_in: (b,b,f)
Transforming
Prolog into the following
Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x1,
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x1,
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x2,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x1,
x2,
x3,
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x1,
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x1,
x2,
x3,
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x1,
x2,
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x1,
x2,
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x1,
x2,
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg(
x1,
x2)
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x1,
x2,
x3,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x1,
x2,
x3,
x5)
Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog
(81) Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x1,
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x1,
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x2,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x1,
x2,
x3,
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x1,
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x1,
x2,
x3,
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x1,
x2,
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x1,
x2,
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x1,
x2,
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg(
x1,
x2)
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x1,
x2,
x3,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x1,
x2,
x3,
x5)
(82) 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:
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → U8_GA(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → MAX_IN_GA(.(X, XS), Y)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U4_GA(X, Y, XS, Z, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS)), Z) → GE_IN_GG(X, Y)
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_GA(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS), Z)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U6_GA(X, Y, XS, Z, gt_in_gg(Y, X))
MAX_IN_GA(.(X, .(Y, XS)), Z) → GT_IN_GG(Y, X)
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_GA(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS), Z)
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → DEL_IN_GGA(Y, .(X, XS), ZS)
DEL_IN_GGA(X, .(Y, YS), YS) → U1_GGA(X, Y, YS, eq_in_gg(X, Y))
DEL_IN_GGA(X, .(Y, YS), YS) → EQ_IN_GG(X, Y)
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → U2_GGA(X, Y, YS, ZS, neq_in_gg(X, Y))
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → NEQ_IN_GG(X, Y)
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_GGA(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS, ZS)
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_GA(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS, YS)
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x1,
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x1,
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x2,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x1,
x2,
x3,
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x1,
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x1,
x2,
x3,
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x1,
x2,
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x1,
x2,
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x1,
x2,
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg(
x1,
x2)
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x1,
x2,
x3,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x1,
x2,
x3,
x5)
MAXSORT_IN_GA(
x1,
x2) =
MAXSORT_IN_GA(
x1)
U8_GA(
x1,
x2,
x3,
x4,
x5) =
U8_GA(
x1,
x2,
x5)
MAX_IN_GA(
x1,
x2) =
MAX_IN_GA(
x1)
U4_GA(
x1,
x2,
x3,
x4,
x5) =
U4_GA(
x1,
x2,
x3,
x5)
GE_IN_GG(
x1,
x2) =
GE_IN_GG(
x1,
x2)
U5_GA(
x1,
x2,
x3,
x4,
x5) =
U5_GA(
x1,
x2,
x3,
x5)
U6_GA(
x1,
x2,
x3,
x4,
x5) =
U6_GA(
x1,
x2,
x3,
x5)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
U7_GA(
x1,
x2,
x3,
x4,
x5) =
U7_GA(
x1,
x2,
x3,
x5)
U9_GA(
x1,
x2,
x3,
x4,
x5) =
U9_GA(
x1,
x2,
x3,
x5)
DEL_IN_GGA(
x1,
x2,
x3) =
DEL_IN_GGA(
x1,
x2)
U1_GGA(
x1,
x2,
x3,
x4) =
U1_GGA(
x1,
x2,
x3,
x4)
EQ_IN_GG(
x1,
x2) =
EQ_IN_GG(
x1,
x2)
U2_GGA(
x1,
x2,
x3,
x4,
x5) =
U2_GGA(
x1,
x2,
x3,
x5)
NEQ_IN_GG(
x1,
x2) =
NEQ_IN_GG(
x1,
x2)
U3_GGA(
x1,
x2,
x3,
x4,
x5) =
U3_GGA(
x1,
x2,
x3,
x5)
U10_GA(
x1,
x2,
x3,
x4,
x5) =
U10_GA(
x1,
x2,
x3,
x5)
We have to consider all (P,R,Pi)-chains
(83) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → U8_GA(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → MAX_IN_GA(.(X, XS), Y)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U4_GA(X, Y, XS, Z, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS)), Z) → GE_IN_GG(X, Y)
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_GA(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS), Z)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U6_GA(X, Y, XS, Z, gt_in_gg(Y, X))
MAX_IN_GA(.(X, .(Y, XS)), Z) → GT_IN_GG(Y, X)
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_GA(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS), Z)
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → DEL_IN_GGA(Y, .(X, XS), ZS)
DEL_IN_GGA(X, .(Y, YS), YS) → U1_GGA(X, Y, YS, eq_in_gg(X, Y))
DEL_IN_GGA(X, .(Y, YS), YS) → EQ_IN_GG(X, Y)
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → U2_GGA(X, Y, YS, ZS, neq_in_gg(X, Y))
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → NEQ_IN_GG(X, Y)
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_GGA(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS, ZS)
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_GA(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS, YS)
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x1,
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x1,
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x2,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x1,
x2,
x3,
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x1,
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x1,
x2,
x3,
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x1,
x2,
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x1,
x2,
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x1,
x2,
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg(
x1,
x2)
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x1,
x2,
x3,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x1,
x2,
x3,
x5)
MAXSORT_IN_GA(
x1,
x2) =
MAXSORT_IN_GA(
x1)
U8_GA(
x1,
x2,
x3,
x4,
x5) =
U8_GA(
x1,
x2,
x5)
MAX_IN_GA(
x1,
x2) =
MAX_IN_GA(
x1)
U4_GA(
x1,
x2,
x3,
x4,
x5) =
U4_GA(
x1,
x2,
x3,
x5)
GE_IN_GG(
x1,
x2) =
GE_IN_GG(
x1,
x2)
U5_GA(
x1,
x2,
x3,
x4,
x5) =
U5_GA(
x1,
x2,
x3,
x5)
U6_GA(
x1,
x2,
x3,
x4,
x5) =
U6_GA(
x1,
x2,
x3,
x5)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
U7_GA(
x1,
x2,
x3,
x4,
x5) =
U7_GA(
x1,
x2,
x3,
x5)
U9_GA(
x1,
x2,
x3,
x4,
x5) =
U9_GA(
x1,
x2,
x3,
x5)
DEL_IN_GGA(
x1,
x2,
x3) =
DEL_IN_GGA(
x1,
x2)
U1_GGA(
x1,
x2,
x3,
x4) =
U1_GGA(
x1,
x2,
x3,
x4)
EQ_IN_GG(
x1,
x2) =
EQ_IN_GG(
x1,
x2)
U2_GGA(
x1,
x2,
x3,
x4,
x5) =
U2_GGA(
x1,
x2,
x3,
x5)
NEQ_IN_GG(
x1,
x2) =
NEQ_IN_GG(
x1,
x2)
U3_GGA(
x1,
x2,
x3,
x4,
x5) =
U3_GGA(
x1,
x2,
x3,
x5)
U10_GA(
x1,
x2,
x3,
x4,
x5) =
U10_GA(
x1,
x2,
x3,
x5)
We have to consider all (P,R,Pi)-chains
(84) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LOPSTR] contains 3 SCCs with 11 less nodes.
(85) Complex Obligation (AND)
(86) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → U2_GGA(X, Y, YS, ZS, neq_in_gg(X, Y))
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS, ZS)
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x1,
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x1,
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x2,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x1,
x2,
x3,
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x1,
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x1,
x2,
x3,
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x1,
x2,
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x1,
x2,
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x1,
x2,
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg(
x1,
x2)
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x1,
x2,
x3,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x1,
x2,
x3,
x5)
DEL_IN_GGA(
x1,
x2,
x3) =
DEL_IN_GGA(
x1,
x2)
U2_GGA(
x1,
x2,
x3,
x4,
x5) =
U2_GGA(
x1,
x2,
x3,
x5)
We have to consider all (P,R,Pi)-chains
(87) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(88) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
DEL_IN_GGA(X, .(Y, YS), .(Y, ZS)) → U2_GGA(X, Y, YS, ZS, neq_in_gg(X, Y))
U2_GGA(X, Y, YS, ZS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS, ZS)
The TRS R consists of the following rules:
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
t =
t
f =
f
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
DEL_IN_GGA(
x1,
x2,
x3) =
DEL_IN_GGA(
x1,
x2)
U2_GGA(
x1,
x2,
x3,
x4,
x5) =
U2_GGA(
x1,
x2,
x3,
x5)
We have to consider all (P,R,Pi)-chains
(89) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(90) Obligation:
Q DP problem:
The TRS P consists of the following rules:
DEL_IN_GGA(X, .(Y, YS)) → U2_GGA(X, Y, YS, neq_in_gg(X, Y))
U2_GGA(X, Y, YS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS)
The TRS R consists of the following rules:
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
The set Q consists of the following terms:
neq_in_gg(x0, x1)
We have to consider all (P,Q,R)-chains.
(91) 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:
- U2_GGA(X, Y, YS, neq_out_gg(X, Y)) → DEL_IN_GGA(X, YS)
The graph contains the following edges 1 >= 1, 4 > 1, 3 >= 2
- DEL_IN_GGA(X, .(Y, YS)) → U2_GGA(X, Y, YS, neq_in_gg(X, Y))
The graph contains the following edges 1 >= 1, 2 > 2, 2 > 3
(92) TRUE
(93) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS), Z)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U4_GA(X, Y, XS, Z, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS)), Z) → U6_GA(X, Y, XS, Z, gt_in_gg(Y, X))
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS), Z)
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x1,
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x1,
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x2,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x1,
x2,
x3,
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x1,
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x1,
x2,
x3,
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x1,
x2,
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x1,
x2,
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x1,
x2,
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg(
x1,
x2)
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x1,
x2,
x3,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x1,
x2,
x3,
x5)
MAX_IN_GA(
x1,
x2) =
MAX_IN_GA(
x1)
U4_GA(
x1,
x2,
x3,
x4,
x5) =
U4_GA(
x1,
x2,
x3,
x5)
U6_GA(
x1,
x2,
x3,
x4,
x5) =
U6_GA(
x1,
x2,
x3,
x5)
We have to consider all (P,R,Pi)-chains
(94) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(95) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U4_GA(X, Y, XS, Z, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS), Z)
MAX_IN_GA(.(X, .(Y, XS)), Z) → U4_GA(X, Y, XS, Z, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS)), Z) → U6_GA(X, Y, XS, Z, gt_in_gg(Y, X))
U6_GA(X, Y, XS, Z, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS), Z)
The TRS R consists of the following rules:
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
gt_in_gg(t, f) → gt_out_gg(t, f)
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
MAX_IN_GA(
x1,
x2) =
MAX_IN_GA(
x1)
U4_GA(
x1,
x2,
x3,
x4,
x5) =
U4_GA(
x1,
x2,
x3,
x5)
U6_GA(
x1,
x2,
x3,
x4,
x5) =
U6_GA(
x1,
x2,
x3,
x5)
We have to consider all (P,R,Pi)-chains
(96) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(97) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U4_GA(X, Y, XS, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS))
MAX_IN_GA(.(X, .(Y, XS))) → U4_GA(X, Y, XS, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS))) → U6_GA(X, Y, XS, gt_in_gg(Y, X))
U6_GA(X, Y, XS, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS))
The TRS R consists of the following rules:
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
gt_in_gg(t, f) → gt_out_gg(t, f)
The set Q consists of the following terms:
ge_in_gg(x0, x1)
gt_in_gg(x0, x1)
We have to consider all (P,Q,R)-chains.
(98) MRRProof (EQUIVALENT transformation)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:
MAX_IN_GA(.(X, .(Y, XS))) → U4_GA(X, Y, XS, ge_in_gg(X, Y))
MAX_IN_GA(.(X, .(Y, XS))) → U6_GA(X, Y, XS, gt_in_gg(Y, X))
U6_GA(X, Y, XS, gt_out_gg(Y, X)) → MAX_IN_GA(.(Y, XS))
Strictly oriented rules of the TRS R:
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
Used ordering: Polynomial interpretation [POLO]:
POL(.(x1, x2)) = 1 + 2·x1 + x2
POL(MAX_IN_GA(x1)) = 2·x1
POL(U4_GA(x1, x2, x3, x4)) = 2 + 2·x1 + 2·x2 + 2·x3 + x4
POL(U6_GA(x1, x2, x3, x4)) = 1 + x1 + x2 + 2·x3 + 2·x4
POL(f) = 0
POL(ge_in_gg(x1, x2)) = 1 + 2·x1 + 2·x2
POL(ge_out_gg(x1, x2)) = 2·x1 + x2
POL(gt_in_gg(x1, x2)) = 1 + x1 + x2
POL(gt_out_gg(x1, x2)) = 1 + 2·x1 + 2·x2
POL(t) = 0
(99) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U4_GA(X, Y, XS, ge_out_gg(X, Y)) → MAX_IN_GA(.(X, XS))
The TRS R consists of the following rules:
gt_in_gg(t, f) → gt_out_gg(t, f)
The set Q consists of the following terms:
ge_in_gg(x0, x1)
gt_in_gg(x0, x1)
We have to consider all (P,Q,R)-chains.
(100) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.
(101) TRUE
(102) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS, YS)
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → U8_GA(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
The TRS R consists of the following rules:
maxsort_in_ga([], []) → maxsort_out_ga([], [])
maxsort_in_ga(.(X, XS), .(Y, YS)) → U8_ga(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
max_in_ga([], f) → max_out_ga([], f)
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
U8_ga(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_ga(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U9_ga(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → U10_ga(X, XS, Y, YS, maxsort_in_ga(ZS, YS))
U10_ga(X, XS, Y, YS, maxsort_out_ga(ZS, YS)) → maxsort_out_ga(.(X, XS), .(Y, YS))
The argument filtering Pi contains the following mapping:
maxsort_in_ga(
x1,
x2) =
maxsort_in_ga(
x1)
[] =
[]
maxsort_out_ga(
x1,
x2) =
maxsort_out_ga(
x1,
x2)
.(
x1,
x2) =
.(
x1,
x2)
U8_ga(
x1,
x2,
x3,
x4,
x5) =
U8_ga(
x1,
x2,
x5)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x1,
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x2,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x1,
x2,
x3,
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x1,
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x1,
x2,
x3,
x5)
U9_ga(
x1,
x2,
x3,
x4,
x5) =
U9_ga(
x1,
x2,
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x1,
x2,
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x1,
x2,
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg(
x1,
x2)
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x1,
x2,
x3,
x5)
U10_ga(
x1,
x2,
x3,
x4,
x5) =
U10_ga(
x1,
x2,
x3,
x5)
MAXSORT_IN_GA(
x1,
x2) =
MAXSORT_IN_GA(
x1)
U8_GA(
x1,
x2,
x3,
x4,
x5) =
U8_GA(
x1,
x2,
x5)
U9_GA(
x1,
x2,
x3,
x4,
x5) =
U9_GA(
x1,
x2,
x3,
x5)
We have to consider all (P,R,Pi)-chains
(103) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(104) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U8_GA(X, XS, Y, YS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, YS, del_in_gga(Y, .(X, XS), ZS))
U9_GA(X, XS, Y, YS, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS, YS)
MAXSORT_IN_GA(.(X, XS), .(Y, YS)) → U8_GA(X, XS, Y, YS, max_in_ga(.(X, XS), Y))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS), YS) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS), .(Y, ZS)) → U2_gga(X, Y, YS, ZS, neq_in_gg(X, Y))
max_in_ga(.(X, []), X) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS)), Z) → U4_ga(X, Y, XS, Z, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS)), Z) → U6_ga(X, Y, XS, Z, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, ZS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, ZS, del_in_gga(X, YS, ZS))
U4_ga(X, Y, XS, Z, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, Z, max_in_ga(.(X, XS), Z))
U6_ga(X, Y, XS, Z, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, Z, max_in_ga(.(Y, XS), Z))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, ZS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, Z, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, Z, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, [], []) → del_out_gga(X1, [], [])
The argument filtering Pi contains the following mapping:
[] =
[]
.(
x1,
x2) =
.(
x1,
x2)
max_in_ga(
x1,
x2) =
max_in_ga(
x1)
max_out_ga(
x1,
x2) =
max_out_ga(
x1,
x2)
U4_ga(
x1,
x2,
x3,
x4,
x5) =
U4_ga(
x1,
x2,
x3,
x5)
ge_in_gg(
x1,
x2) =
ge_in_gg(
x1,
x2)
t =
t
ge_out_gg(
x1,
x2) =
ge_out_gg(
x1,
x2)
f =
f
U5_ga(
x1,
x2,
x3,
x4,
x5) =
U5_ga(
x1,
x2,
x3,
x5)
U6_ga(
x1,
x2,
x3,
x4,
x5) =
U6_ga(
x1,
x2,
x3,
x5)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U7_ga(
x1,
x2,
x3,
x4,
x5) =
U7_ga(
x1,
x2,
x3,
x5)
del_in_gga(
x1,
x2,
x3) =
del_in_gga(
x1,
x2)
del_out_gga(
x1,
x2,
x3) =
del_out_gga(
x1,
x2,
x3)
U1_gga(
x1,
x2,
x3,
x4) =
U1_gga(
x1,
x2,
x3,
x4)
eq_in_gg(
x1,
x2) =
eq_in_gg(
x1,
x2)
eq_out_gg(
x1,
x2) =
eq_out_gg(
x1,
x2)
U2_gga(
x1,
x2,
x3,
x4,
x5) =
U2_gga(
x1,
x2,
x3,
x5)
neq_in_gg(
x1,
x2) =
neq_in_gg(
x1,
x2)
neq_out_gg(
x1,
x2) =
neq_out_gg(
x1,
x2)
U3_gga(
x1,
x2,
x3,
x4,
x5) =
U3_gga(
x1,
x2,
x3,
x5)
MAXSORT_IN_GA(
x1,
x2) =
MAXSORT_IN_GA(
x1)
U8_GA(
x1,
x2,
x3,
x4,
x5) =
U8_GA(
x1,
x2,
x5)
U9_GA(
x1,
x2,
x3,
x4,
x5) =
U9_GA(
x1,
x2,
x3,
x5)
We have to consider all (P,R,Pi)-chains
(105) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(106) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(X, XS, max_out_ga(.(X, XS), Y)) → U9_GA(X, XS, Y, del_in_gga(Y, .(X, XS)))
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(X, XS)) → U8_GA(X, XS, max_in_ga(.(X, XS)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(107) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
U8_GA(
X,
XS,
max_out_ga(
.(
X,
XS),
Y)) →
U9_GA(
X,
XS,
Y,
del_in_gga(
Y,
.(
X,
XS))) at position [3] we obtained the following new rules [LPAR04]:
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U1_gga(x0, x1, x2, eq_in_gg(x0, x1)))
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
(108) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(X, XS)) → U8_GA(X, XS, max_in_ga(.(X, XS)))
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U1_gga(x0, x1, x2, eq_in_gg(x0, x1)))
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(109) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
MAXSORT_IN_GA(
.(
X,
XS)) →
U8_GA(
X,
XS,
max_in_ga(
.(
X,
XS))) at position [2] we obtained the following new rules [LPAR04]:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x1, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x0, x1, x2, gt_in_gg(x1, x0)))
(110) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U1_gga(x0, x1, x2, eq_in_gg(x0, x1)))
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x1, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x0, x1, x2, gt_in_gg(x1, x0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(111) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
U8_GA(
x1,
x2,
max_out_ga(
.(
x1,
x2),
x0)) →
U9_GA(
x1,
x2,
x0,
U1_gga(
x0,
x1,
x2,
eq_in_gg(
x0,
x1))) at position [3,3] we obtained the following new rules [LPAR04]:
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, U1_gga(t, t, y1, eq_out_gg(t, t)))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, U1_gga(f, f, y1, eq_out_gg(f, f)))
(112) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x1, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x0, x1, x2, gt_in_gg(x1, x0)))
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, U1_gga(t, t, y1, eq_out_gg(t, t)))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, U1_gga(f, f, y1, eq_out_gg(f, f)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(113) Rewriting (EQUIVALENT transformation)
By rewriting [LPAR04] the rule
U8_GA(
t,
y1,
max_out_ga(
.(
t,
y1),
t)) →
U9_GA(
t,
y1,
t,
U1_gga(
t,
t,
y1,
eq_out_gg(
t,
t))) at position [3] we obtained the following new rules [LPAR04]:
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, del_out_gga(t, .(t, y1), y1))
(114) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x1, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x0, x1, x2, gt_in_gg(x1, x0)))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, U1_gga(f, f, y1, eq_out_gg(f, f)))
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, del_out_gga(t, .(t, y1), y1))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(115) Rewriting (EQUIVALENT transformation)
By rewriting [LPAR04] the rule
U8_GA(
f,
y1,
max_out_ga(
.(
f,
y1),
f)) →
U9_GA(
f,
y1,
f,
U1_gga(
f,
f,
y1,
eq_out_gg(
f,
f))) at position [3] we obtained the following new rules [LPAR04]:
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, del_out_gga(f, .(f, y1), y1))
(116) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
U8_GA(x1, x2, max_out_ga(.(x1, x2), x0)) → U9_GA(x1, x2, x0, U2_gga(x0, x1, x2, neq_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x1, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x0, x1, x2, gt_in_gg(x1, x0)))
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, del_out_gga(t, .(t, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, del_out_gga(f, .(f, y1), y1))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(117) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
U8_GA(
x1,
x2,
max_out_ga(
.(
x1,
x2),
x0)) →
U9_GA(
x1,
x2,
x0,
U2_gga(
x0,
x1,
x2,
neq_in_gg(
x0,
x1))) at position [3,3] we obtained the following new rules [LPAR04]:
U8_GA(f, y1, max_out_ga(.(f, y1), t)) → U9_GA(f, y1, t, U2_gga(t, f, y1, neq_out_gg(t, f)))
U8_GA(t, y1, max_out_ga(.(t, y1), f)) → U9_GA(t, y1, f, U2_gga(f, t, y1, neq_out_gg(f, t)))
(118) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U4_ga(x0, x1, x2, ge_in_gg(x0, x1)))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x0, x1, x2, gt_in_gg(x1, x0)))
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, del_out_gga(t, .(t, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, del_out_gga(f, .(f, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), t)) → U9_GA(f, y1, t, U2_gga(t, f, y1, neq_out_gg(t, f)))
U8_GA(t, y1, max_out_ga(.(t, y1), f)) → U9_GA(t, y1, f, U2_gga(f, t, y1, neq_out_gg(f, t)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(119) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
MAXSORT_IN_GA(
.(
x0,
.(
x1,
x2))) →
U8_GA(
x0,
.(
x1,
x2),
U4_ga(
x0,
x1,
x2,
ge_in_gg(
x0,
x1))) at position [2,3] we obtained the following new rules [LPAR04]:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
(120) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(x0, .(x1, x2))) → U8_GA(x0, .(x1, x2), U6_ga(x0, x1, x2, gt_in_gg(x1, x0)))
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, del_out_gga(t, .(t, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, del_out_gga(f, .(f, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), t)) → U9_GA(f, y1, t, U2_gga(t, f, y1, neq_out_gg(t, f)))
U8_GA(t, y1, max_out_ga(.(t, y1), f)) → U9_GA(t, y1, f, U2_gga(f, t, y1, neq_out_gg(f, t)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(121) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
MAXSORT_IN_GA(
.(
x0,
.(
x1,
x2))) →
U8_GA(
x0,
.(
x1,
x2),
U6_ga(
x0,
x1,
x2,
gt_in_gg(
x1,
x0))) at position [2,3] we obtained the following new rules [LPAR04]:
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
(122) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(X, XS, Y, del_out_gga(Y, .(X, XS), ZS)) → MAXSORT_IN_GA(ZS)
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, del_out_gga(t, .(t, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, del_out_gga(f, .(f, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), t)) → U9_GA(f, y1, t, U2_gga(t, f, y1, neq_out_gg(t, f)))
U8_GA(t, y1, max_out_ga(.(t, y1), f)) → U9_GA(t, y1, f, U2_gga(f, t, y1, neq_out_gg(f, t)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(123) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U9_GA(
X,
XS,
Y,
del_out_gga(
Y,
.(
X,
XS),
ZS)) →
MAXSORT_IN_GA(
ZS) we obtained the following new rules [LPAR04]:
U9_GA(t, z0, t, del_out_gga(t, .(t, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, f, del_out_gga(f, .(f, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
(124) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
U8_GA(t, y1, max_out_ga(.(t, y1), t)) → U9_GA(t, y1, t, del_out_gga(t, .(t, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, del_out_gga(f, .(f, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), t)) → U9_GA(f, y1, t, U2_gga(t, f, y1, neq_out_gg(t, f)))
U8_GA(t, y1, max_out_ga(.(t, y1), f)) → U9_GA(t, y1, f, U2_gga(f, t, y1, neq_out_gg(f, t)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U9_GA(t, z0, t, del_out_gga(t, .(t, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, f, del_out_gga(f, .(f, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(125) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U8_GA(
t,
y1,
max_out_ga(
.(
t,
y1),
t)) →
U9_GA(
t,
y1,
t,
del_out_gga(
t,
.(
t,
y1),
y1)) we obtained the following new rules [LPAR04]:
U8_GA(t, [], max_out_ga(.(t, []), t)) → U9_GA(t, [], t, del_out_gga(t, .(t, []), []))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
(126) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
U8_GA(f, y1, max_out_ga(.(f, y1), f)) → U9_GA(f, y1, f, del_out_gga(f, .(f, y1), y1))
U8_GA(f, y1, max_out_ga(.(f, y1), t)) → U9_GA(f, y1, t, U2_gga(t, f, y1, neq_out_gg(t, f)))
U8_GA(t, y1, max_out_ga(.(t, y1), f)) → U9_GA(t, y1, f, U2_gga(f, t, y1, neq_out_gg(f, t)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U9_GA(t, z0, t, del_out_gga(t, .(t, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, f, del_out_gga(f, .(f, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, [], max_out_ga(.(t, []), t)) → U9_GA(t, [], t, del_out_gga(t, .(t, []), []))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(127) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U8_GA(
f,
y1,
max_out_ga(
.(
f,
y1),
f)) →
U9_GA(
f,
y1,
f,
del_out_gga(
f,
.(
f,
y1),
y1)) we obtained the following new rules [LPAR04]:
U8_GA(f, [], max_out_ga(.(f, []), f)) → U9_GA(f, [], f, del_out_gga(f, .(f, []), []))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
(128) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
U8_GA(f, y1, max_out_ga(.(f, y1), t)) → U9_GA(f, y1, t, U2_gga(t, f, y1, neq_out_gg(t, f)))
U8_GA(t, y1, max_out_ga(.(t, y1), f)) → U9_GA(t, y1, f, U2_gga(f, t, y1, neq_out_gg(f, t)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U9_GA(t, z0, t, del_out_gga(t, .(t, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, f, del_out_gga(f, .(f, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, [], max_out_ga(.(t, []), t)) → U9_GA(t, [], t, del_out_gga(t, .(t, []), []))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U8_GA(f, [], max_out_ga(.(f, []), f)) → U9_GA(f, [], f, del_out_gga(f, .(f, []), []))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(129) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U8_GA(
f,
y1,
max_out_ga(
.(
f,
y1),
t)) →
U9_GA(
f,
y1,
t,
U2_gga(
t,
f,
y1,
neq_out_gg(
t,
f))) we obtained the following new rules [LPAR04]:
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
(130) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
U8_GA(t, y1, max_out_ga(.(t, y1), f)) → U9_GA(t, y1, f, U2_gga(f, t, y1, neq_out_gg(f, t)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U9_GA(t, z0, t, del_out_gga(t, .(t, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, f, del_out_gga(f, .(f, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, [], max_out_ga(.(t, []), t)) → U9_GA(t, [], t, del_out_gga(t, .(t, []), []))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U8_GA(f, [], max_out_ga(.(f, []), f)) → U9_GA(f, [], f, del_out_gga(f, .(f, []), []))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(131) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U8_GA(
t,
y1,
max_out_ga(
.(
t,
y1),
f)) →
U9_GA(
t,
y1,
f,
U2_gga(
f,
t,
y1,
neq_out_gg(
f,
t))) we obtained the following new rules [LPAR04]:
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
(132) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U9_GA(t, z0, t, del_out_gga(t, .(t, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, f, del_out_gga(f, .(f, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, [], max_out_ga(.(t, []), t)) → U9_GA(t, [], t, del_out_gga(t, .(t, []), []))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U8_GA(f, [], max_out_ga(.(f, []), f)) → U9_GA(f, [], f, del_out_gga(f, .(f, []), []))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(133) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U9_GA(
t,
z0,
t,
del_out_gga(
t,
.(
t,
z0),
z0)) →
MAXSORT_IN_GA(
z0) we obtained the following new rules [LPAR04]:
U9_GA(t, [], t, del_out_gga(t, .(t, []), [])) → MAXSORT_IN_GA([])
U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
(134) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U9_GA(f, z0, f, del_out_gga(f, .(f, z0), z0)) → MAXSORT_IN_GA(z0)
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, [], max_out_ga(.(t, []), t)) → U9_GA(t, [], t, del_out_gga(t, .(t, []), []))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U8_GA(f, [], max_out_ga(.(f, []), f)) → U9_GA(f, [], f, del_out_gga(f, .(f, []), []))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, [], t, del_out_gga(t, .(t, []), [])) → MAXSORT_IN_GA([])
U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(135) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
(136) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(f, [], max_out_ga(.(f, []), f)) → U9_GA(f, [], f, del_out_gga(f, .(f, []), []))
U9_GA(f, z0, f, del_out_gga(f, .(f, z0), z0)) → MAXSORT_IN_GA(z0)
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(137) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U9_GA(
f,
z0,
f,
del_out_gga(
f,
.(
f,
z0),
z0)) →
MAXSORT_IN_GA(
z0) we obtained the following new rules [LPAR04]:
U9_GA(f, [], f, del_out_gga(f, .(f, []), [])) → MAXSORT_IN_GA([])
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
(138) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(f, [], max_out_ga(.(f, []), f)) → U9_GA(f, [], f, del_out_gga(f, .(f, []), []))
MAXSORT_IN_GA(.(x0, [])) → U8_GA(x0, [], max_out_ga(.(x0, []), x0))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, [], f, del_out_gga(f, .(f, []), [])) → MAXSORT_IN_GA([])
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(139) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.
(140) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, z0, t, del_out_gga(t, .(f, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(141) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U9_GA(
f,
z0,
t,
del_out_gga(
t,
.(
f,
z0),
x3)) →
MAXSORT_IN_GA(
x3) we obtained the following new rules [LPAR04]:
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
(142) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, z0, f, del_out_gga(f, .(t, z0), x3)) → MAXSORT_IN_GA(x3)
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(143) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U9_GA(
t,
z0,
f,
del_out_gga(
f,
.(
t,
z0),
x3)) →
MAXSORT_IN_GA(
x3) we obtained the following new rules [LPAR04]:
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
(144) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(145) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
t,
.(
t,
z0),
t,
del_out_gga(
t,
.(
t,
.(
t,
z0)),
.(
t,
z0))) →
MAXSORT_IN_GA(
.(
t,
z0)) we obtained the following new rules [LPAR04]:
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
(146) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), t)) → U9_GA(t, .(t, z0), t, del_out_gga(t, .(t, .(t, z0)), .(t, z0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(147) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U8_GA(
t,
.(
t,
z0),
max_out_ga(
.(
t,
.(
t,
z0)),
t)) →
U9_GA(
t,
.(
t,
z0),
t,
del_out_gga(
t,
.(
t,
.(
t,
z0)),
.(
t,
z0))) we obtained the following new rules [LPAR04]:
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
(148) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(149) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
t,
.(
f,
z0),
t,
del_out_gga(
t,
.(
t,
.(
f,
z0)),
.(
f,
z0))) →
MAXSORT_IN_GA(
.(
f,
z0)) we obtained the following new rules [LPAR04]:
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
(150) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), t)) → U9_GA(t, .(f, z0), t, del_out_gga(t, .(t, .(f, z0)), .(f, z0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(151) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U8_GA(
t,
.(
f,
z0),
max_out_ga(
.(
t,
.(
f,
z0)),
t)) →
U9_GA(
t,
.(
f,
z0),
t,
del_out_gga(
t,
.(
t,
.(
f,
z0)),
.(
f,
z0))) we obtained the following new rules [LPAR04]:
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
(152) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0))) → MAXSORT_IN_GA(.(f, z0))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(153) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
f,
.(
f,
z0),
f,
del_out_gga(
f,
.(
f,
.(
f,
z0)),
.(
f,
z0))) →
MAXSORT_IN_GA(
.(
f,
z0)) we obtained the following new rules [LPAR04]:
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
(154) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), f)) → U9_GA(f, .(f, z0), f, del_out_gga(f, .(f, .(f, z0)), .(f, z0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(155) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U8_GA(
f,
.(
f,
z0),
max_out_ga(
.(
f,
.(
f,
z0)),
f)) →
U9_GA(
f,
.(
f,
z0),
f,
del_out_gga(
f,
.(
f,
.(
f,
z0)),
.(
f,
z0))) we obtained the following new rules [LPAR04]:
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
(156) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0))) → MAXSORT_IN_GA(.(t, z0))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(157) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
f,
.(
t,
z0),
f,
del_out_gga(
f,
.(
f,
.(
t,
z0)),
.(
t,
z0))) →
MAXSORT_IN_GA(
.(
t,
z0)) we obtained the following new rules [LPAR04]:
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
(158) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), f)) → U9_GA(f, .(t, z0), f, del_out_gga(f, .(f, .(t, z0)), .(t, z0)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(159) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U8_GA(
f,
.(
t,
z0),
max_out_ga(
.(
f,
.(
t,
z0)),
f)) →
U9_GA(
f,
.(
t,
z0),
f,
del_out_gga(
f,
.(
f,
.(
t,
z0)),
.(
t,
z0))) we obtained the following new rules [LPAR04]:
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
(160) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(t, z0), t, del_out_gga(t, .(f, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(161) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
f,
.(
t,
z0),
t,
del_out_gga(
t,
.(
f,
.(
t,
z0)),
x1)) →
MAXSORT_IN_GA(
x1) we obtained the following new rules [LPAR04]:
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
(162) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(f, .(f, z0), t, del_out_gga(t, .(f, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(163) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
f,
.(
f,
z0),
t,
del_out_gga(
t,
.(
f,
.(
f,
z0)),
x1)) →
MAXSORT_IN_GA(
x1) we obtained the following new rules [LPAR04]:
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
(164) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(165) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
(166) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, z0), f, del_out_gga(f, .(t, .(t, z0)), x1)) → MAXSORT_IN_GA(x1)
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(167) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
t,
.(
t,
z0),
f,
del_out_gga(
f,
.(
t,
.(
t,
z0)),
x1)) →
MAXSORT_IN_GA(
x1) we obtained the following new rules [LPAR04]:
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
(168) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(169) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
(170) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, z0), f, del_out_gga(f, .(t, .(f, z0)), x1)) → MAXSORT_IN_GA(x1)
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(171) ForwardInstantiation (EQUIVALENT transformation)
By forward instantiating [JAR06] the rule
U9_GA(
t,
.(
f,
z0),
f,
del_out_gga(
f,
.(
t,
.(
f,
z0)),
x1)) →
MAXSORT_IN_GA(
x1) we obtained the following new rules [LPAR04]:
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
(172) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(173) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
U8_GA(f, .(t, .(t, y_0)), max_out_ga(.(f, .(t, .(t, y_0))), f)) → U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(f, .(t, .(f, y_0)), max_out_ga(.(f, .(t, .(f, y_0))), f)) → U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0))))
U8_GA(f, .(f, .(f, y_0)), max_out_ga(.(f, .(f, .(f, y_0))), f)) → U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(f, .(f, .(t, y_0)), max_out_ga(.(f, .(f, .(t, y_0))), f)) → U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(.(x1, x2)) = x1 + x2
POL(MAXSORT_IN_GA(x1)) = x1
POL(U1_gga(x1, x2, x3, x4)) = x2 + x3
POL(U2_gga(x1, x2, x3, x4)) = x3 + x4
POL(U3_gga(x1, x2, x3, x4)) = x2 + x4
POL(U4_ga(x1, x2, x3, x4)) = 0
POL(U5_ga(x1, x2, x3, x4)) = 0
POL(U6_ga(x1, x2, x3, x4)) = 0
POL(U7_ga(x1, x2, x3, x4)) = 0
POL(U8_GA(x1, x2, x3)) = x1 + x2
POL(U9_GA(x1, x2, x3, x4)) = x4
POL([]) = 0
POL(del_in_gga(x1, x2)) = x2
POL(del_out_gga(x1, x2, x3)) = x3
POL(eq_in_gg(x1, x2)) = 0
POL(eq_out_gg(x1, x2)) = 0
POL(f) = 1
POL(ge_in_gg(x1, x2)) = x2
POL(ge_out_gg(x1, x2)) = 0
POL(gt_in_gg(x1, x2)) = 1
POL(gt_out_gg(x1, x2)) = 0
POL(max_in_ga(x1)) = 0
POL(max_out_ga(x1, x2)) = 0
POL(neq_in_gg(x1, x2)) = x2
POL(neq_out_gg(x1, x2)) = x2
POL(t) = 0
The following usable rules [FROCOS05] were oriented:
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X1, []) → del_out_gga(X1, [], [])
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
(174) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(f, .(t, .(t, y_0)), f, del_out_gga(f, .(f, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, .(f, y_0)), f, del_out_gga(f, .(f, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(f, .(f, y_0)), f, del_out_gga(f, .(f, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, .(t, y_0)), f, del_out_gga(f, .(f, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(175) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
(176) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(177) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
U8_GA(t, .(f, .(f, y_0)), max_out_ga(.(t, .(f, .(f, y_0))), t)) → U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0))))
U8_GA(t, .(f, .(t, y_0)), max_out_ga(.(t, .(f, .(t, y_0))), t)) → U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(.(x1, x2)) = x1
POL(MAXSORT_IN_GA(x1)) = x1
POL(U1_gga(x1, x2, x3, x4)) = 0
POL(U2_gga(x1, x2, x3, x4)) = x4
POL(U3_gga(x1, x2, x3, x4)) = x2
POL(U4_ga(x1, x2, x3, x4)) = 0
POL(U5_ga(x1, x2, x3, x4)) = 0
POL(U6_ga(x1, x2, x3, x4)) = 0
POL(U7_ga(x1, x2, x3, x4)) = 0
POL(U8_GA(x1, x2, x3)) = x1
POL(U9_GA(x1, x2, x3, x4)) = x4
POL([]) = 0
POL(del_in_gga(x1, x2)) = 1
POL(del_out_gga(x1, x2, x3)) = x3
POL(eq_in_gg(x1, x2)) = 0
POL(eq_out_gg(x1, x2)) = 0
POL(f) = 0
POL(ge_in_gg(x1, x2)) = 0
POL(ge_out_gg(x1, x2)) = 0
POL(gt_in_gg(x1, x2)) = 1 + x1
POL(gt_out_gg(x1, x2)) = x1
POL(max_in_ga(x1)) = 0
POL(max_out_ga(x1, x2)) = 0
POL(neq_in_gg(x1, x2)) = 1
POL(neq_out_gg(x1, x2)) = x2
POL(t) = 1
The following usable rules [FROCOS05] were oriented:
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
(178) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(f, .(f, y_0)), t, del_out_gga(t, .(t, .(f, .(f, y_0))), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(t, .(f, .(t, y_0)), t, del_out_gga(t, .(t, .(f, .(t, y_0))), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(179) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
(180) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(181) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
U8_GA(t, .(t, .(t, y_0)), max_out_ga(.(t, .(t, .(t, y_0))), t)) → U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0))))
U8_GA(t, .(t, .(f, y_0)), max_out_ga(.(t, .(t, .(f, y_0))), t)) → U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(.(x1, x2)) = 1 + x2
POL(MAXSORT_IN_GA(x1)) = x1
POL(U1_gga(x1, x2, x3, x4)) = 1 + x3
POL(U2_gga(x1, x2, x3, x4)) = x3 + x4
POL(U3_gga(x1, x2, x3, x4)) = 1 + x4
POL(U4_ga(x1, x2, x3, x4)) = 0
POL(U5_ga(x1, x2, x3, x4)) = 0
POL(U6_ga(x1, x2, x3, x4)) = 0
POL(U7_ga(x1, x2, x3, x4)) = 0
POL(U8_GA(x1, x2, x3)) = 1 + x2
POL(U9_GA(x1, x2, x3, x4)) = x4
POL([]) = 0
POL(del_in_gga(x1, x2)) = x2
POL(del_out_gga(x1, x2, x3)) = x3
POL(eq_in_gg(x1, x2)) = 0
POL(eq_out_gg(x1, x2)) = 0
POL(f) = 0
POL(ge_in_gg(x1, x2)) = 0
POL(ge_out_gg(x1, x2)) = 0
POL(gt_in_gg(x1, x2)) = 0
POL(gt_out_gg(x1, x2)) = 0
POL(max_in_ga(x1)) = 0
POL(max_out_ga(x1, x2)) = 0
POL(neq_in_gg(x1, x2)) = 1
POL(neq_out_gg(x1, x2)) = 1
POL(t) = 0
The following usable rules [FROCOS05] were oriented:
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X1, []) → del_out_gga(X1, [], [])
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
(182) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U9_GA(t, .(t, .(t, y_0)), t, del_out_gga(t, .(t, .(t, .(t, y_0))), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, .(f, y_0)), t, del_out_gga(t, .(t, .(t, .(f, y_0))), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(183) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
(184) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(185) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(t, x0), f, del_out_gga(f, .(t, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(t, y_0)))) → MAXSORT_IN_GA(.(t, .(t, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(t, .(f, y_0)))) → MAXSORT_IN_GA(.(t, .(f, y_0)))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]:
| POL(U9_GA(x1, x2, x3, x4)) = | 0A | + | 0A | · | x1 | + | -I | · | x2 | + | 0A | · | x3 | + | -I | · | x4 |
| POL(.(x1, x2)) = | 0A | + | 0A | · | x1 | + | -I | · | x2 |
| POL(del_out_gga(x1, x2, x3)) = | -I | + | 0A | · | x1 | + | 1A | · | x2 | + | -I | · | x3 |
| POL(MAXSORT_IN_GA(x1)) = | -I | + | 0A | · | x1 |
| POL(U8_GA(x1, x2, x3)) = | 0A | + | -I | · | x1 | + | -I | · | x2 | + | 0A | · | x3 |
| POL(U4_ga(x1, x2, x3, x4)) = | 0A | + | 0A | · | x1 | + | -I | · | x2 | + | -I | · | x3 | + | -I | · | x4 |
| POL(ge_out_gg(x1, x2)) = | -I | + | -I | · | x1 | + | 0A | · | x2 |
| POL(max_out_ga(x1, x2)) = | 0A | + | 0A | · | x1 | + | 0A | · | x2 |
| POL(U2_gga(x1, x2, x3, x4)) = | 1A | + | 0A | · | x1 | + | 0A | · | x2 | + | 0A | · | x3 | + | -I | · | x4 |
| POL(neq_out_gg(x1, x2)) = | -I | + | -I | · | x1 | + | 0A | · | x2 |
| POL(U6_ga(x1, x2, x3, x4)) = | -I | + | -I | · | x1 | + | -I | · | x2 | + | -I | · | x3 | + | 0A | · | x4 |
| POL(gt_out_gg(x1, x2)) = | 0A | + | 0A | · | x1 | + | 0A | · | x2 |
| POL(U5_ga(x1, x2, x3, x4)) = | -I | + | -I | · | x1 | + | -I | · | x2 | + | -I | · | x3 | + | 0A | · | x4 |
| POL(max_in_ga(x1)) = | -I | + | 0A | · | x1 |
| POL(U3_gga(x1, x2, x3, x4)) = | -I | + | 3A | · | x1 | + | -I | · | x2 | + | 5A | · | x3 | + | 2A | · | x4 |
| POL(del_in_gga(x1, x2)) = | 0A | + | -I | · | x1 | + | 0A | · | x2 |
| POL(U7_ga(x1, x2, x3, x4)) = | 0A | + | 0A | · | x1 | + | 0A | · | x2 | + | -I | · | x3 | + | 0A | · | x4 |
| POL(neq_in_gg(x1, x2)) = | 0A | + | -I | · | x1 | + | 1A | · | x2 |
| POL(U1_gga(x1, x2, x3, x4)) = | -I | + | -I | · | x1 | + | -I | · | x2 | + | 0A | · | x3 | + | 0A | · | x4 |
| POL(eq_in_gg(x1, x2)) = | -I | + | 0A | · | x1 | + | -I | · | x2 |
| POL(eq_out_gg(x1, x2)) = | 5A | + | -I | · | x1 | + | -I | · | x2 |
| POL(ge_in_gg(x1, x2)) = | 0A | + | 0A | · | x1 | + | -I | · | x2 |
| POL(gt_in_gg(x1, x2)) = | 0A | + | -I | · | x1 | + | 0A | · | x2 |
The following usable rules [FROCOS05] were oriented:
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
(186) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MAXSORT_IN_GA(.(t, .(t, y2))) → U8_GA(t, .(t, y2), U4_ga(t, t, y2, ge_out_gg(t, t)))
U8_GA(t, .(t, z0), max_out_ga(.(t, .(t, z0)), f)) → U9_GA(t, .(t, z0), f, U2_gga(f, t, .(t, z0), neq_out_gg(f, t)))
MAXSORT_IN_GA(.(t, .(f, y2))) → U8_GA(t, .(f, y2), U4_ga(t, f, y2, ge_out_gg(t, f)))
U8_GA(t, .(f, z0), max_out_ga(.(t, .(f, z0)), f)) → U9_GA(t, .(f, z0), f, U2_gga(f, t, .(f, z0), neq_out_gg(f, t)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
U9_GA(t, .(f, x0), f, del_out_gga(f, .(t, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(187) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 6 less nodes.
(188) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U8_GA(f, .(f, z0), max_out_ga(.(f, .(f, z0)), t)) → U9_GA(f, .(f, z0), t, U2_gga(t, f, .(f, z0), neq_out_gg(t, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
MAXSORT_IN_GA(.(f, .(f, y2))) → U8_GA(f, .(f, y2), U4_ga(f, f, y2, ge_out_gg(f, f)))
U9_GA(f, .(f, x0), t, del_out_gga(t, .(f, .(f, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
MAXSORT_IN_GA(.(f, .(t, y2))) → U8_GA(f, .(t, y2), U6_ga(f, t, y2, gt_out_gg(t, f)))
U8_GA(f, .(t, z0), max_out_ga(.(f, .(t, z0)), t)) → U9_GA(f, .(t, z0), t, U2_gga(t, f, .(t, z0), neq_out_gg(t, f)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(f, y_0)))) → MAXSORT_IN_GA(.(f, .(f, y_0)))
U9_GA(f, .(t, x0), t, del_out_gga(t, .(f, .(t, x0)), .(f, .(t, y_0)))) → MAXSORT_IN_GA(.(f, .(t, y_0)))
The TRS R consists of the following rules:
del_in_gga(X, .(Y, YS)) → U1_gga(X, Y, YS, eq_in_gg(X, Y))
del_in_gga(X, .(Y, YS)) → U2_gga(X, Y, YS, neq_in_gg(X, Y))
max_in_ga(.(X, [])) → max_out_ga(.(X, []), X)
max_in_ga(.(X, .(Y, XS))) → U4_ga(X, Y, XS, ge_in_gg(X, Y))
max_in_ga(.(X, .(Y, XS))) → U6_ga(X, Y, XS, gt_in_gg(Y, X))
U1_gga(X, Y, YS, eq_out_gg(X, Y)) → del_out_gga(X, .(Y, YS), YS)
U2_gga(X, Y, YS, neq_out_gg(X, Y)) → U3_gga(X, Y, YS, del_in_gga(X, YS))
U4_ga(X, Y, XS, ge_out_gg(X, Y)) → U5_ga(X, Y, XS, max_in_ga(.(X, XS)))
U6_ga(X, Y, XS, gt_out_gg(Y, X)) → U7_ga(X, Y, XS, max_in_ga(.(Y, XS)))
eq_in_gg(t, t) → eq_out_gg(t, t)
eq_in_gg(f, f) → eq_out_gg(f, f)
neq_in_gg(t, f) → neq_out_gg(t, f)
neq_in_gg(f, t) → neq_out_gg(f, t)
U3_gga(X, Y, YS, del_out_gga(X, YS, ZS)) → del_out_gga(X, .(Y, YS), .(Y, ZS))
ge_in_gg(t, t) → ge_out_gg(t, t)
ge_in_gg(t, f) → ge_out_gg(t, f)
ge_in_gg(f, f) → ge_out_gg(f, f)
U5_ga(X, Y, XS, max_out_ga(.(X, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
gt_in_gg(t, f) → gt_out_gg(t, f)
U7_ga(X, Y, XS, max_out_ga(.(Y, XS), Z)) → max_out_ga(.(X, .(Y, XS)), Z)
del_in_gga(X1, []) → del_out_gga(X1, [], [])
The set Q consists of the following terms:
del_in_gga(x0, x1)
max_in_ga(x0)
U1_gga(x0, x1, x2, x3)
U2_gga(x0, x1, x2, x3)
U4_ga(x0, x1, x2, x3)
U6_ga(x0, x1, x2, x3)
eq_in_gg(x0, x1)
neq_in_gg(x0, x1)
U3_gga(x0, x1, x2, x3)
ge_in_gg(x0, x1)
U5_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U7_ga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.