(0) Obligation:
Clauses:
qs(.(X, Xs), Ys) :- ','(part(X, Xs, Littles, Bigs), ','(qs(Littles, Ls), ','(qs(Bigs, Bs), app(Ls, .(X, Bs), Ys)))).
qs([], []).
part(X, .(Y, Xs), .(Y, Ls), Bs) :- ','(gt(X, Y), part(X, Xs, Ls, Bs)).
part(X, .(Y, Xs), Ls, .(Y, Bs)) :- ','(le(X, Y), part(X, Xs, Ls, Bs)).
part(X, [], [], []).
app(.(X, Xs), Ys, .(X, Zs)) :- app(Xs, Ys, Zs).
app([], Ys, Ys).
gt(s(X), s(Y)) :- gt(X, Y).
gt(s(0), 0).
le(s(X), s(Y)) :- le(X, Y).
le(0, s(X)).
le(0, 0).
Queries:
qs(a,g).
(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:
qs_in: (f,b) (b,f) (f,f)
part_in: (f,f,f,f) (b,f,f,f) (b,b,f,f)
gt_in: (f,f) (b,f) (b,b)
le_in: (b,f) (f,f) (b,b)
app_in: (b,b,f) (b,f,f) (b,f,b)
Transforming
Prolog into the following
Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog
(2) Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
(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:
QS_IN_AG(.(X, Xs), Ys) → U1_AG(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
QS_IN_AG(.(X, Xs), Ys) → PART_IN_AAAA(X, Xs, Littles, Bigs)
PART_IN_AAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_AAAA(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
PART_IN_AAAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_AA(X, Y)
GT_IN_AA(s(X), s(Y)) → U10_AA(X, Y, gt_in_aa(X, Y))
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
U5_AAAA(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_AAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U5_AAAA(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GAAA(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_GA(X, Y)
GT_IN_GA(s(X), s(Y)) → U10_GA(X, Y, gt_in_ga(X, Y))
GT_IN_GA(s(X), s(Y)) → GT_IN_GA(X, Y)
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_GAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GAAA(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_GA(X, Y)
LE_IN_GA(s(X), s(Y)) → U11_GA(X, Y, le_in_ga(X, Y))
LE_IN_GA(s(X), s(Y)) → LE_IN_GA(X, Y)
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_GAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_AAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_AAAA(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
PART_IN_AAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_AA(X, Y)
LE_IN_AA(s(X), s(Y)) → U11_AA(X, Y, le_in_aa(X, Y))
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
U7_AAAA(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_AAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_AAAA(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
U1_AG(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AG(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_AG(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
QS_IN_GA(.(X, Xs), Ys) → U1_GA(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
QS_IN_GA(.(X, Xs), Ys) → PART_IN_GGAA(X, Xs, Littles, Bigs)
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GGAA(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_GG(X, Y)
GT_IN_GG(s(X), s(Y)) → U10_GG(X, Y, gt_in_gg(X, Y))
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_GGAA(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GGAA(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_GG(X, Y)
LE_IN_GG(s(X), s(Y)) → U11_GG(X, Y, le_in_gg(X, Y))
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_GGAA(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_GA(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs, Bs)
U3_GA(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_GA(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
U3_GA(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → APP_IN_GGA(Ls, .(X, Bs), Ys)
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → U9_GGA(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GGA(Xs, Ys, Zs)
U2_AG(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_AG(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
U2_AG(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
QS_IN_AA(.(X, Xs), Ys) → U1_AA(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
QS_IN_AA(.(X, Xs), Ys) → PART_IN_AAAA(X, Xs, Littles, Bigs)
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_AA(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
U3_AA(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_AA(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
U3_AA(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → APP_IN_GAA(Ls, .(X, Bs), Ys)
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → U9_GAA(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAA(Xs, Ys, Zs)
U3_AG(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_AG(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
U3_AG(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → APP_IN_GAG(Ls, .(X, Bs), Ys)
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → U9_GAG(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAG(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
QS_IN_AG(
x1,
x2) =
QS_IN_AG(
x2)
U1_AG(
x1,
x2,
x3,
x4) =
U1_AG(
x3,
x4)
PART_IN_AAAA(
x1,
x2,
x3,
x4) =
PART_IN_AAAA
U5_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_AAAA(
x6)
GT_IN_AA(
x1,
x2) =
GT_IN_AA
U10_AA(
x1,
x2,
x3) =
U10_AA(
x3)
U6_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_AAAA(
x2,
x6)
PART_IN_GAAA(
x1,
x2,
x3,
x4) =
PART_IN_GAAA(
x1)
U5_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GAAA(
x1,
x6)
GT_IN_GA(
x1,
x2) =
GT_IN_GA(
x1)
U10_GA(
x1,
x2,
x3) =
U10_GA(
x3)
U6_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_GAAA(
x2,
x6)
U7_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GAAA(
x1,
x6)
LE_IN_GA(
x1,
x2) =
LE_IN_GA(
x1)
U11_GA(
x1,
x2,
x3) =
U11_GA(
x3)
U8_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_GAAA(
x6)
U7_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_AAAA(
x6)
LE_IN_AA(
x1,
x2) =
LE_IN_AA
U11_AA(
x1,
x2,
x3) =
U11_AA(
x3)
U8_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_AAAA(
x6)
U2_AG(
x1,
x2,
x3,
x4,
x5) =
U2_AG(
x3,
x5)
QS_IN_GA(
x1,
x2) =
QS_IN_GA(
x1)
U1_GA(
x1,
x2,
x3,
x4) =
U1_GA(
x1,
x4)
PART_IN_GGAA(
x1,
x2,
x3,
x4) =
PART_IN_GGAA(
x1,
x2)
U5_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GGAA(
x1,
x2,
x3,
x6)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
U10_GG(
x1,
x2,
x3) =
U10_GG(
x3)
U6_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_GGAA(
x2,
x6)
U7_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GGAA(
x1,
x2,
x3,
x6)
LE_IN_GG(
x1,
x2) =
LE_IN_GG(
x1,
x2)
U11_GG(
x1,
x2,
x3) =
U11_GG(
x3)
U8_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_GGAA(
x2,
x6)
U2_GA(
x1,
x2,
x3,
x4,
x5) =
U2_GA(
x1,
x4,
x5)
U3_GA(
x1,
x2,
x3,
x4,
x5) =
U3_GA(
x1,
x4,
x5)
U4_GA(
x1,
x2,
x3,
x4) =
U4_GA(
x4)
APP_IN_GGA(
x1,
x2,
x3) =
APP_IN_GGA(
x1,
x2)
U9_GGA(
x1,
x2,
x3,
x4,
x5) =
U9_GGA(
x1,
x5)
U3_AG(
x1,
x2,
x3,
x4,
x5) =
U3_AG(
x3,
x4,
x5)
QS_IN_AA(
x1,
x2) =
QS_IN_AA
U1_AA(
x1,
x2,
x3,
x4) =
U1_AA(
x4)
U2_AA(
x1,
x2,
x3,
x4,
x5) =
U2_AA(
x5)
U3_AA(
x1,
x2,
x3,
x4,
x5) =
U3_AA(
x4,
x5)
U4_AA(
x1,
x2,
x3,
x4) =
U4_AA(
x4)
APP_IN_GAA(
x1,
x2,
x3) =
APP_IN_GAA(
x1)
U9_GAA(
x1,
x2,
x3,
x4,
x5) =
U9_GAA(
x5)
U4_AG(
x1,
x2,
x3,
x4) =
U4_AG(
x4)
APP_IN_GAG(
x1,
x2,
x3) =
APP_IN_GAG(
x1,
x3)
U9_GAG(
x1,
x2,
x3,
x4,
x5) =
U9_GAG(
x5)
We have to consider all (P,R,Pi)-chains
(4) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
QS_IN_AG(.(X, Xs), Ys) → U1_AG(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
QS_IN_AG(.(X, Xs), Ys) → PART_IN_AAAA(X, Xs, Littles, Bigs)
PART_IN_AAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_AAAA(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
PART_IN_AAAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_AA(X, Y)
GT_IN_AA(s(X), s(Y)) → U10_AA(X, Y, gt_in_aa(X, Y))
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
U5_AAAA(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_AAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U5_AAAA(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GAAA(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_GA(X, Y)
GT_IN_GA(s(X), s(Y)) → U10_GA(X, Y, gt_in_ga(X, Y))
GT_IN_GA(s(X), s(Y)) → GT_IN_GA(X, Y)
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_GAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GAAA(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_GA(X, Y)
LE_IN_GA(s(X), s(Y)) → U11_GA(X, Y, le_in_ga(X, Y))
LE_IN_GA(s(X), s(Y)) → LE_IN_GA(X, Y)
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_GAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_AAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_AAAA(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
PART_IN_AAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_AA(X, Y)
LE_IN_AA(s(X), s(Y)) → U11_AA(X, Y, le_in_aa(X, Y))
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
U7_AAAA(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_AAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_AAAA(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
U1_AG(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AG(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_AG(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
QS_IN_GA(.(X, Xs), Ys) → U1_GA(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
QS_IN_GA(.(X, Xs), Ys) → PART_IN_GGAA(X, Xs, Littles, Bigs)
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GGAA(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_GG(X, Y)
GT_IN_GG(s(X), s(Y)) → U10_GG(X, Y, gt_in_gg(X, Y))
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_GGAA(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GGAA(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_GG(X, Y)
LE_IN_GG(s(X), s(Y)) → U11_GG(X, Y, le_in_gg(X, Y))
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_GGAA(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_GA(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs, Bs)
U3_GA(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_GA(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
U3_GA(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → APP_IN_GGA(Ls, .(X, Bs), Ys)
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → U9_GGA(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GGA(Xs, Ys, Zs)
U2_AG(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_AG(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
U2_AG(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
QS_IN_AA(.(X, Xs), Ys) → U1_AA(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
QS_IN_AA(.(X, Xs), Ys) → PART_IN_AAAA(X, Xs, Littles, Bigs)
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_AA(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
U3_AA(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_AA(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
U3_AA(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → APP_IN_GAA(Ls, .(X, Bs), Ys)
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → U9_GAA(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAA(Xs, Ys, Zs)
U3_AG(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_AG(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
U3_AG(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → APP_IN_GAG(Ls, .(X, Bs), Ys)
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → U9_GAG(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAG(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
QS_IN_AG(
x1,
x2) =
QS_IN_AG(
x2)
U1_AG(
x1,
x2,
x3,
x4) =
U1_AG(
x3,
x4)
PART_IN_AAAA(
x1,
x2,
x3,
x4) =
PART_IN_AAAA
U5_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_AAAA(
x6)
GT_IN_AA(
x1,
x2) =
GT_IN_AA
U10_AA(
x1,
x2,
x3) =
U10_AA(
x3)
U6_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_AAAA(
x2,
x6)
PART_IN_GAAA(
x1,
x2,
x3,
x4) =
PART_IN_GAAA(
x1)
U5_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GAAA(
x1,
x6)
GT_IN_GA(
x1,
x2) =
GT_IN_GA(
x1)
U10_GA(
x1,
x2,
x3) =
U10_GA(
x3)
U6_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_GAAA(
x2,
x6)
U7_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GAAA(
x1,
x6)
LE_IN_GA(
x1,
x2) =
LE_IN_GA(
x1)
U11_GA(
x1,
x2,
x3) =
U11_GA(
x3)
U8_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_GAAA(
x6)
U7_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_AAAA(
x6)
LE_IN_AA(
x1,
x2) =
LE_IN_AA
U11_AA(
x1,
x2,
x3) =
U11_AA(
x3)
U8_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_AAAA(
x6)
U2_AG(
x1,
x2,
x3,
x4,
x5) =
U2_AG(
x3,
x5)
QS_IN_GA(
x1,
x2) =
QS_IN_GA(
x1)
U1_GA(
x1,
x2,
x3,
x4) =
U1_GA(
x1,
x4)
PART_IN_GGAA(
x1,
x2,
x3,
x4) =
PART_IN_GGAA(
x1,
x2)
U5_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GGAA(
x1,
x2,
x3,
x6)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
U10_GG(
x1,
x2,
x3) =
U10_GG(
x3)
U6_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_GGAA(
x2,
x6)
U7_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GGAA(
x1,
x2,
x3,
x6)
LE_IN_GG(
x1,
x2) =
LE_IN_GG(
x1,
x2)
U11_GG(
x1,
x2,
x3) =
U11_GG(
x3)
U8_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_GGAA(
x2,
x6)
U2_GA(
x1,
x2,
x3,
x4,
x5) =
U2_GA(
x1,
x4,
x5)
U3_GA(
x1,
x2,
x3,
x4,
x5) =
U3_GA(
x1,
x4,
x5)
U4_GA(
x1,
x2,
x3,
x4) =
U4_GA(
x4)
APP_IN_GGA(
x1,
x2,
x3) =
APP_IN_GGA(
x1,
x2)
U9_GGA(
x1,
x2,
x3,
x4,
x5) =
U9_GGA(
x1,
x5)
U3_AG(
x1,
x2,
x3,
x4,
x5) =
U3_AG(
x3,
x4,
x5)
QS_IN_AA(
x1,
x2) =
QS_IN_AA
U1_AA(
x1,
x2,
x3,
x4) =
U1_AA(
x4)
U2_AA(
x1,
x2,
x3,
x4,
x5) =
U2_AA(
x5)
U3_AA(
x1,
x2,
x3,
x4,
x5) =
U3_AA(
x4,
x5)
U4_AA(
x1,
x2,
x3,
x4) =
U4_AA(
x4)
APP_IN_GAA(
x1,
x2,
x3) =
APP_IN_GAA(
x1)
U9_GAA(
x1,
x2,
x3,
x4,
x5) =
U9_GAA(
x5)
U4_AG(
x1,
x2,
x3,
x4) =
U4_AG(
x4)
APP_IN_GAG(
x1,
x2,
x3) =
APP_IN_GAG(
x1,
x3)
U9_GAG(
x1,
x2,
x3,
x4,
x5) =
U9_GAG(
x5)
We have to consider all (P,R,Pi)-chains
(5) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LOPSTR] contains 13 SCCs with 42 less nodes.
(6) Complex Obligation (AND)
(7) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAG(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
APP_IN_GAG(
x1,
x2,
x3) =
APP_IN_GAG(
x1,
x3)
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:
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAG(Xs, Ys, Zs)
R is empty.
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
APP_IN_GAG(
x1,
x2,
x3) =
APP_IN_GAG(
x1,
x3)
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:
APP_IN_GAG(.(X, Xs), .(X, Zs)) → APP_IN_GAG(Xs, Zs)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(12) QDPSizeChangeProof (EQUIVALENT transformation)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.
From the DPs we obtained the following set of size-change graphs:
- APP_IN_GAG(.(X, Xs), .(X, Zs)) → APP_IN_GAG(Xs, Zs)
The graph contains the following edges 1 > 1, 2 > 2
(13) TRUE
(14) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAA(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
APP_IN_GAA(
x1,
x2,
x3) =
APP_IN_GAA(
x1)
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:
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAA(Xs, Ys, Zs)
R is empty.
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
APP_IN_GAA(
x1,
x2,
x3) =
APP_IN_GAA(
x1)
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:
APP_IN_GAA(.(X, Xs)) → APP_IN_GAA(Xs)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(19) 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:
- APP_IN_GAA(.(X, Xs)) → APP_IN_GAA(Xs)
The graph contains the following edges 1 > 1
(20) TRUE
(21) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GGA(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
APP_IN_GGA(
x1,
x2,
x3) =
APP_IN_GGA(
x1,
x2)
We have to consider all (P,R,Pi)-chains
(22) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(23) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GGA(Xs, Ys, Zs)
R is empty.
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
APP_IN_GGA(
x1,
x2,
x3) =
APP_IN_GGA(
x1,
x2)
We have to consider all (P,R,Pi)-chains
(24) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(25) Obligation:
Q DP problem:
The TRS P consists of the following rules:
APP_IN_GGA(.(X, Xs), Ys) → APP_IN_GGA(Xs, Ys)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(26) 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:
- APP_IN_GGA(.(X, Xs), Ys) → APP_IN_GGA(Xs, Ys)
The graph contains the following edges 1 > 1, 2 >= 2
(27) TRUE
(28) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
LE_IN_GG(
x1,
x2) =
LE_IN_GG(
x1,
x2)
We have to consider all (P,R,Pi)-chains
(29) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(30) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
(31) PiDPToQDPProof (EQUIVALENT transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(32) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(33) 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:
- LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2
(34) TRUE
(35) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
We have to consider all (P,R,Pi)-chains
(36) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(37) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
(38) PiDPToQDPProof (EQUIVALENT transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(39) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(40) 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:
- GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2
(41) TRUE
(42) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GGAA(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GGAA(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
PART_IN_GGAA(
x1,
x2,
x3,
x4) =
PART_IN_GGAA(
x1,
x2)
U5_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GGAA(
x1,
x2,
x3,
x6)
U7_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GGAA(
x1,
x2,
x3,
x6)
We have to consider all (P,R,Pi)-chains
(43) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(44) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GGAA(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GGAA(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
The TRS R consists of the following rules:
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
0 =
0
.(
x1,
x2) =
.(
x1,
x2)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
PART_IN_GGAA(
x1,
x2,
x3,
x4) =
PART_IN_GGAA(
x1,
x2)
U5_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GGAA(
x1,
x2,
x3,
x6)
U7_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GGAA(
x1,
x2,
x3,
x6)
We have to consider all (P,R,Pi)-chains
(45) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(46) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GGAA(X, Y, Xs, gt_out_gg) → PART_IN_GGAA(X, Xs)
PART_IN_GGAA(X, .(Y, Xs)) → U5_GGAA(X, Y, Xs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs)) → U7_GGAA(X, Y, Xs, le_in_gg(X, Y))
U7_GGAA(X, Y, Xs, le_out_gg) → PART_IN_GGAA(X, Xs)
The TRS R consists of the following rules:
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U10_gg(gt_out_gg) → gt_out_gg
U11_gg(le_out_gg) → le_out_gg
The set Q consists of the following terms:
gt_in_gg(x0, x1)
le_in_gg(x0, x1)
U10_gg(x0)
U11_gg(x0)
We have to consider all (P,Q,R)-chains.
(47) 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:
- PART_IN_GGAA(X, .(Y, Xs)) → U5_GGAA(X, Y, Xs, gt_in_gg(X, Y))
The graph contains the following edges 1 >= 1, 2 > 2, 2 > 3
- PART_IN_GGAA(X, .(Y, Xs)) → U7_GGAA(X, Y, Xs, le_in_gg(X, Y))
The graph contains the following edges 1 >= 1, 2 > 2, 2 > 3
- U5_GGAA(X, Y, Xs, gt_out_gg) → PART_IN_GGAA(X, Xs)
The graph contains the following edges 1 >= 1, 3 >= 2
- U7_GGAA(X, Y, Xs, le_out_gg) → PART_IN_GGAA(X, Xs)
The graph contains the following edges 1 >= 1, 3 >= 2
(48) TRUE
(49) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs, Bs)
QS_IN_GA(.(X, Xs), Ys) → U1_GA(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
QS_IN_GA(
x1,
x2) =
QS_IN_GA(
x1)
U1_GA(
x1,
x2,
x3,
x4) =
U1_GA(
x1,
x4)
U2_GA(
x1,
x2,
x3,
x4,
x5) =
U2_GA(
x1,
x4,
x5)
We have to consider all (P,R,Pi)-chains
(50) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(51) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs, Bs)
QS_IN_GA(.(X, Xs), Ys) → U1_GA(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
The TRS R consists of the following rules:
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
qs_in_ga([], []) → qs_out_ga([], [])
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
0 =
0
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
QS_IN_GA(
x1,
x2) =
QS_IN_GA(
x1)
U1_GA(
x1,
x2,
x3,
x4) =
U1_GA(
x1,
x4)
U2_GA(
x1,
x2,
x3,
x4,
x5) =
U2_GA(
x1,
x4,
x5)
We have to consider all (P,R,Pi)-chains
(52) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(53) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_GA(X, part_out_ggaa(Littles, Bigs)) → U2_GA(X, Bigs, qs_in_ga(Littles))
U2_GA(X, Bigs, qs_out_ga(Ls)) → QS_IN_GA(Bigs)
QS_IN_GA(.(X, Xs)) → U1_GA(X, part_in_ggaa(X, Xs))
U1_GA(X, part_out_ggaa(Littles, Bigs)) → QS_IN_GA(Littles)
The TRS R consists of the following rules:
qs_in_ga(.(X, Xs)) → U1_ga(X, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa([], [])
U1_ga(X, part_out_ggaa(Littles, Bigs)) → U2_ga(X, Bigs, qs_in_ga(Littles))
U5_ggaa(X, Y, Xs, gt_out_gg) → U6_ggaa(Y, part_in_ggaa(X, Xs))
U7_ggaa(X, Y, Xs, le_out_gg) → U8_ggaa(Y, part_in_ggaa(X, Xs))
U2_ga(X, Bigs, qs_out_ga(Ls)) → U3_ga(X, Ls, qs_in_ga(Bigs))
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
U6_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(.(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U8_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(Ls, .(Y, Bs))
U3_ga(X, Ls, qs_out_ga(Bs)) → U4_ga(app_in_gga(Ls, .(X, Bs)))
U10_gg(gt_out_gg) → gt_out_gg
U11_gg(le_out_gg) → le_out_gg
U4_ga(app_out_gga(Ys)) → qs_out_ga(Ys)
app_in_gga(.(X, Xs), Ys) → U9_gga(X, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga(Ys)
U9_gga(X, app_out_gga(Zs)) → app_out_gga(.(X, Zs))
The set Q consists of the following terms:
qs_in_ga(x0)
part_in_ggaa(x0, x1)
U1_ga(x0, x1)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U2_ga(x0, x1, x2)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1)
le_in_gg(x0, x1)
U8_ggaa(x0, x1)
U3_ga(x0, x1, x2)
U10_gg(x0)
U11_gg(x0)
U4_ga(x0)
app_in_gga(x0, x1)
U9_gga(x0, x1)
We have to consider all (P,Q,R)-chains.
(54) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
QS_IN_GA(.(X, Xs)) → U1_GA(X, part_in_ggaa(X, Xs))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:
| POL(U1_GA(x1, x2)) = | 1 | + | | · | x1 | + | | · | x2 |
| POL(part_out_ggaa(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(U2_GA(x1, x2, x3)) = | 1 | + | | · | x1 | + | | · | x2 | + | | · | x3 |
| POL(qs_in_ga(x1)) = | | + | | · | x1 |
| POL(qs_out_ga(x1)) = | | + | | · | x1 |
| POL(QS_IN_GA(x1)) = | 1 | + | | · | x1 |
| POL(.(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(part_in_ggaa(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(U1_ga(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(U5_ggaa(x1, x2, x3, x4)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 | + | | · | x4 |
| POL(gt_in_gg(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(U7_ggaa(x1, x2, x3, x4)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 | + | | · | x4 |
| POL(le_in_gg(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(U2_ga(x1, x2, x3)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 |
| POL(U3_ga(x1, x2, x3)) = | | + | | · | x1 | + | | · | x2 | + | | · | x3 |
| POL(app_in_gga(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(U6_ggaa(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(U8_ggaa(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(U9_gga(x1, x2)) = | | + | | · | x1 | + | | · | x2 |
| POL(app_out_gga(x1)) = | | + | | · | x1 |
The following usable rules [FROCOS05] were oriented:
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa([], [])
U5_ggaa(X, Y, Xs, gt_out_gg) → U6_ggaa(Y, part_in_ggaa(X, Xs))
U6_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(.(Y, Ls), Bs)
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U7_ggaa(X, Y, Xs, le_out_gg) → U8_ggaa(Y, part_in_ggaa(X, Xs))
U8_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(Ls, .(Y, Bs))
U10_gg(gt_out_gg) → gt_out_gg
U11_gg(le_out_gg) → le_out_gg
(55) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_GA(X, part_out_ggaa(Littles, Bigs)) → U2_GA(X, Bigs, qs_in_ga(Littles))
U2_GA(X, Bigs, qs_out_ga(Ls)) → QS_IN_GA(Bigs)
U1_GA(X, part_out_ggaa(Littles, Bigs)) → QS_IN_GA(Littles)
The TRS R consists of the following rules:
qs_in_ga(.(X, Xs)) → U1_ga(X, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa([], [])
U1_ga(X, part_out_ggaa(Littles, Bigs)) → U2_ga(X, Bigs, qs_in_ga(Littles))
U5_ggaa(X, Y, Xs, gt_out_gg) → U6_ggaa(Y, part_in_ggaa(X, Xs))
U7_ggaa(X, Y, Xs, le_out_gg) → U8_ggaa(Y, part_in_ggaa(X, Xs))
U2_ga(X, Bigs, qs_out_ga(Ls)) → U3_ga(X, Ls, qs_in_ga(Bigs))
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
U6_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(.(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U8_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(Ls, .(Y, Bs))
U3_ga(X, Ls, qs_out_ga(Bs)) → U4_ga(app_in_gga(Ls, .(X, Bs)))
U10_gg(gt_out_gg) → gt_out_gg
U11_gg(le_out_gg) → le_out_gg
U4_ga(app_out_gga(Ys)) → qs_out_ga(Ys)
app_in_gga(.(X, Xs), Ys) → U9_gga(X, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga(Ys)
U9_gga(X, app_out_gga(Zs)) → app_out_gga(.(X, Zs))
The set Q consists of the following terms:
qs_in_ga(x0)
part_in_ggaa(x0, x1)
U1_ga(x0, x1)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U2_ga(x0, x1, x2)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1)
le_in_gg(x0, x1)
U8_ggaa(x0, x1)
U3_ga(x0, x1, x2)
U10_gg(x0)
U11_gg(x0)
U4_ga(x0)
app_in_gga(x0, x1)
U9_gga(x0, x1)
We have to consider all (P,Q,R)-chains.
(56) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.
(57) TRUE
(58) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
LE_IN_AA(
x1,
x2) =
LE_IN_AA
We have to consider all (P,R,Pi)-chains
(59) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(60) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
R is empty.
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
LE_IN_AA(
x1,
x2) =
LE_IN_AA
We have to consider all (P,R,Pi)-chains
(61) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(62) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LE_IN_AA → LE_IN_AA
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(63) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.
s =
LE_IN_AA evaluates to t =
LE_IN_AAThus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Matcher: [ ]
- Semiunifier: [ ]
Rewriting sequenceThe DP semiunifies directly so there is only one rewrite step from LE_IN_AA to LE_IN_AA.
(64) FALSE
(65) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_GA(s(X), s(Y)) → LE_IN_GA(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
LE_IN_GA(
x1,
x2) =
LE_IN_GA(
x1)
We have to consider all (P,R,Pi)-chains
(66) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(67) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_GA(s(X), s(Y)) → LE_IN_GA(X, Y)
R is empty.
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
LE_IN_GA(
x1,
x2) =
LE_IN_GA(
x1)
We have to consider all (P,R,Pi)-chains
(68) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(69) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LE_IN_GA(s(X)) → LE_IN_GA(X)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(70) 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:
- LE_IN_GA(s(X)) → LE_IN_GA(X)
The graph contains the following edges 1 > 1
(71) TRUE
(72) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_GA(s(X), s(Y)) → GT_IN_GA(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
GT_IN_GA(
x1,
x2) =
GT_IN_GA(
x1)
We have to consider all (P,R,Pi)-chains
(73) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(74) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_GA(s(X), s(Y)) → GT_IN_GA(X, Y)
R is empty.
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
GT_IN_GA(
x1,
x2) =
GT_IN_GA(
x1)
We have to consider all (P,R,Pi)-chains
(75) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(76) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT_IN_GA(s(X)) → GT_IN_GA(X)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(77) 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:
- GT_IN_GA(s(X)) → GT_IN_GA(X)
The graph contains the following edges 1 > 1
(78) TRUE
(79) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GAAA(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GAAA(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
PART_IN_GAAA(
x1,
x2,
x3,
x4) =
PART_IN_GAAA(
x1)
U5_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GAAA(
x1,
x6)
U7_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GAAA(
x1,
x6)
We have to consider all (P,R,Pi)-chains
(80) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(81) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GAAA(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GAAA(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
The TRS R consists of the following rules:
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
The argument filtering Pi contains the following mapping:
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
.(
x1,
x2) =
.(
x1,
x2)
PART_IN_GAAA(
x1,
x2,
x3,
x4) =
PART_IN_GAAA(
x1)
U5_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GAAA(
x1,
x6)
U7_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GAAA(
x1,
x6)
We have to consider all (P,R,Pi)-chains
(82) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(83) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, gt_out_ga(Y)) → PART_IN_GAAA(X)
PART_IN_GAAA(X) → U5_GAAA(X, gt_in_ga(X))
PART_IN_GAAA(X) → U7_GAAA(X, le_in_ga(X))
U7_GAAA(X, le_out_ga) → PART_IN_GAAA(X)
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
We have to consider all (P,Q,R)-chains.
(84) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
PART_IN_GAAA(
X) →
U5_GAAA(
X,
gt_in_ga(
X)) at position [1] we obtained the following new rules [LPAR04]:
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(0))
(85) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, gt_out_ga(Y)) → PART_IN_GAAA(X)
PART_IN_GAAA(X) → U7_GAAA(X, le_in_ga(X))
U7_GAAA(X, le_out_ga) → PART_IN_GAAA(X)
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(0))
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
We have to consider all (P,Q,R)-chains.
(86) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
PART_IN_GAAA(
X) →
U7_GAAA(
X,
le_in_ga(
X)) at position [1] we obtained the following new rules [LPAR04]:
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(le_in_ga(x0)))
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga)
(87) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, gt_out_ga(Y)) → PART_IN_GAAA(X)
U7_GAAA(X, le_out_ga) → PART_IN_GAAA(X)
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(0))
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(le_in_ga(x0)))
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga)
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
We have to consider all (P,Q,R)-chains.
(88) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U5_GAAA(
X,
gt_out_ga(
Y)) →
PART_IN_GAAA(
X) we obtained the following new rules [LPAR04]:
U5_GAAA(s(z0), gt_out_ga(x1)) → PART_IN_GAAA(s(z0))
U5_GAAA(s(0), gt_out_ga(0)) → PART_IN_GAAA(s(0))
(89) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U7_GAAA(X, le_out_ga) → PART_IN_GAAA(X)
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(0))
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(le_in_ga(x0)))
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga)
U5_GAAA(s(z0), gt_out_ga(x1)) → PART_IN_GAAA(s(z0))
U5_GAAA(s(0), gt_out_ga(0)) → PART_IN_GAAA(s(0))
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
We have to consider all (P,Q,R)-chains.
(90) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U7_GAAA(
X,
le_out_ga) →
PART_IN_GAAA(
X) we obtained the following new rules [LPAR04]:
U7_GAAA(s(z0), le_out_ga) → PART_IN_GAAA(s(z0))
U7_GAAA(0, le_out_ga) → PART_IN_GAAA(0)
(91) Obligation:
Q DP problem:
The TRS P consists of the following rules:
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(0))
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(le_in_ga(x0)))
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga)
U5_GAAA(s(z0), gt_out_ga(x1)) → PART_IN_GAAA(s(z0))
U5_GAAA(s(0), gt_out_ga(0)) → PART_IN_GAAA(s(0))
U7_GAAA(s(z0), le_out_ga) → PART_IN_GAAA(s(z0))
U7_GAAA(0, le_out_ga) → PART_IN_GAAA(0)
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
We have to consider all (P,Q,R)-chains.
(92) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs.
(93) Complex Obligation (AND)
(94) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U7_GAAA(0, le_out_ga) → PART_IN_GAAA(0)
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga)
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
We have to consider all (P,Q,R)-chains.
(95) UsableRulesProof (EQUIVALENT transformation)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
(96) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U7_GAAA(0, le_out_ga) → PART_IN_GAAA(0)
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga)
R is empty.
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
We have to consider all (P,Q,R)-chains.
(97) QReductionProof (EQUIVALENT transformation)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
(98) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U7_GAAA(0, le_out_ga) → PART_IN_GAAA(0)
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(99) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:
s =
PART_IN_GAAA(
0) evaluates to t =
PART_IN_GAAA(
0)
Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Matcher: [ ]
- Semiunifier: [ ]
Rewriting sequencePART_IN_GAAA(0) →
U7_GAAA(
0,
le_out_ga)
with rule
PART_IN_GAAA(
0) →
U7_GAAA(
0,
le_out_ga) at position [] and matcher [ ]
U7_GAAA(0, le_out_ga) →
PART_IN_GAAA(
0)
with rule
U7_GAAA(
0,
le_out_ga) →
PART_IN_GAAA(
0)
Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence
All these steps are and every following step will be a correct step w.r.t to Q.
(100) FALSE
(101) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GAAA(s(z0), gt_out_ga(x1)) → PART_IN_GAAA(s(z0))
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(gt_in_ga(x0)))
U5_GAAA(s(0), gt_out_ga(0)) → PART_IN_GAAA(s(0))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(0))
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(le_in_ga(x0)))
U7_GAAA(s(z0), le_out_ga) → PART_IN_GAAA(s(z0))
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0)
U11_ga(x0)
We have to consider all (P,Q,R)-chains.
(102) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:
s =
PART_IN_GAAA(
s(
0)) evaluates to t =
PART_IN_GAAA(
s(
0))
Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Semiunifier: [ ]
- Matcher: [ ]
Rewriting sequencePART_IN_GAAA(s(0)) →
U5_GAAA(
s(
0),
gt_out_ga(
0))
with rule
PART_IN_GAAA(
s(
0)) →
U5_GAAA(
s(
0),
gt_out_ga(
0)) at position [] and matcher [ ]
U5_GAAA(s(0), gt_out_ga(0)) →
PART_IN_GAAA(
s(
0))
with rule
U5_GAAA(
s(
z0),
gt_out_ga(
x1)) →
PART_IN_GAAA(
s(
z0))
Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence
All these steps are and every following step will be a correct step w.r.t to Q.
(103) FALSE
(104) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
GT_IN_AA(
x1,
x2) =
GT_IN_AA
We have to consider all (P,R,Pi)-chains
(105) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(106) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
R is empty.
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
GT_IN_AA(
x1,
x2) =
GT_IN_AA
We have to consider all (P,R,Pi)-chains
(107) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(108) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT_IN_AA → GT_IN_AA
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(109) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.
s =
GT_IN_AA evaluates to t =
GT_IN_AAThus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Semiunifier: [ ]
- Matcher: [ ]
Rewriting sequenceThe DP semiunifies directly so there is only one rewrite step from GT_IN_AA to GT_IN_AA.
(110) FALSE
(111) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
QS_IN_AA(.(X, Xs), Ys) → U1_AA(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x2)
qs_out_ag(
x1,
x2) =
qs_out_ag
QS_IN_AA(
x1,
x2) =
QS_IN_AA
U1_AA(
x1,
x2,
x3,
x4) =
U1_AA(
x4)
U2_AA(
x1,
x2,
x3,
x4,
x5) =
U2_AA(
x5)
We have to consider all (P,R,Pi)-chains
(112) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(113) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
QS_IN_AA(.(X, Xs), Ys) → U1_AA(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
The TRS R consists of the following rules:
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
qs_in_ga([], []) → qs_out_ga([], [])
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
The argument filtering Pi contains the following mapping:
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x3)
le_out_ga(
x1,
x2) =
le_out_ga
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x2,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x3)
le_out_gg(
x1,
x2) =
le_out_gg
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x2,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x3)
QS_IN_AA(
x1,
x2) =
QS_IN_AA
U1_AA(
x1,
x2,
x3,
x4) =
U1_AA(
x4)
U2_AA(
x1,
x2,
x3,
x4,
x5) =
U2_AA(
x5)
We have to consider all (P,R,Pi)-chains
(114) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(115) Obligation:
Q DP problem:
The TRS P consists of the following rules:
QS_IN_AA → U1_AA(part_in_aaaa)
U1_AA(part_out_aaaa(Littles)) → U2_AA(qs_in_ga(Littles))
U2_AA(qs_out_ga(Ls)) → QS_IN_AA
The TRS R consists of the following rules:
part_in_aaaa → U5_aaaa(gt_in_aa)
part_in_aaaa → U7_aaaa(le_in_aa)
part_in_aaaa → part_out_aaaa([])
qs_in_ga(.(X, Xs)) → U1_ga(X, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([])
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
U1_ga(X, part_out_ggaa(Littles, Bigs)) → U2_ga(X, Bigs, qs_in_ga(Littles))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U6_aaaa(Y, part_out_gaaa(Ls)) → part_out_aaaa(.(Y, Ls))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U8_aaaa(part_out_gaaa(Ls)) → part_out_aaaa(Ls)
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa([], [])
U2_ga(X, Bigs, qs_out_ga(Ls)) → U3_ga(X, Ls, qs_in_ga(Bigs))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa([])
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
U5_ggaa(X, Y, Xs, gt_out_gg) → U6_ggaa(Y, part_in_ggaa(X, Xs))
U7_ggaa(X, Y, Xs, le_out_gg) → U8_ggaa(Y, part_in_ggaa(X, Xs))
U3_ga(X, Ls, qs_out_ga(Bs)) → U4_ga(app_in_gga(Ls, .(X, Bs)))
U5_gaaa(X, gt_out_ga(Y)) → U6_gaaa(Y, part_in_gaaa(X))
U7_gaaa(X, le_out_ga) → U8_gaaa(part_in_gaaa(X))
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
U6_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(.(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U8_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(Ls, .(Y, Bs))
U4_ga(app_out_gga(Ys)) → qs_out_ga(Ys)
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
U6_gaaa(Y, part_out_gaaa(Ls)) → part_out_gaaa(.(Y, Ls))
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U8_gaaa(part_out_gaaa(Ls)) → part_out_gaaa(Ls)
U10_gg(gt_out_gg) → gt_out_gg
U11_gg(le_out_gg) → le_out_gg
app_in_gga(.(X, Xs), Ys) → U9_gga(X, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga(Ys)
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
U9_gga(X, app_out_gga(Zs)) → app_out_gga(.(X, Zs))
The set Q consists of the following terms:
part_in_aaaa
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1)
le_in_gg(x0, x1)
U8_ggaa(x0, x1)
U4_ga(x0)
gt_in_ga(x0)
U6_gaaa(x0, x1)
le_in_ga(x0)
U8_gaaa(x0)
U10_gg(x0)
U11_gg(x0)
app_in_gga(x0, x1)
U10_ga(x0)
U11_ga(x0)
U9_gga(x0, x1)
We have to consider all (P,Q,R)-chains.
(116) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
QS_IN_AA →
U1_AA(
part_in_aaaa) at position [0] we obtained the following new rules [LPAR04]:
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
(117) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_AA(part_out_aaaa(Littles)) → U2_AA(qs_in_ga(Littles))
U2_AA(qs_out_ga(Ls)) → QS_IN_AA
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
The TRS R consists of the following rules:
part_in_aaaa → U5_aaaa(gt_in_aa)
part_in_aaaa → U7_aaaa(le_in_aa)
part_in_aaaa → part_out_aaaa([])
qs_in_ga(.(X, Xs)) → U1_ga(X, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([])
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
U1_ga(X, part_out_ggaa(Littles, Bigs)) → U2_ga(X, Bigs, qs_in_ga(Littles))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U6_aaaa(Y, part_out_gaaa(Ls)) → part_out_aaaa(.(Y, Ls))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U8_aaaa(part_out_gaaa(Ls)) → part_out_aaaa(Ls)
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa([], [])
U2_ga(X, Bigs, qs_out_ga(Ls)) → U3_ga(X, Ls, qs_in_ga(Bigs))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa([])
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
U5_ggaa(X, Y, Xs, gt_out_gg) → U6_ggaa(Y, part_in_ggaa(X, Xs))
U7_ggaa(X, Y, Xs, le_out_gg) → U8_ggaa(Y, part_in_ggaa(X, Xs))
U3_ga(X, Ls, qs_out_ga(Bs)) → U4_ga(app_in_gga(Ls, .(X, Bs)))
U5_gaaa(X, gt_out_ga(Y)) → U6_gaaa(Y, part_in_gaaa(X))
U7_gaaa(X, le_out_ga) → U8_gaaa(part_in_gaaa(X))
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
U6_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(.(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U8_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(Ls, .(Y, Bs))
U4_ga(app_out_gga(Ys)) → qs_out_ga(Ys)
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
U6_gaaa(Y, part_out_gaaa(Ls)) → part_out_gaaa(.(Y, Ls))
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U8_gaaa(part_out_gaaa(Ls)) → part_out_gaaa(Ls)
U10_gg(gt_out_gg) → gt_out_gg
U11_gg(le_out_gg) → le_out_gg
app_in_gga(.(X, Xs), Ys) → U9_gga(X, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga(Ys)
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_ga(le_out_ga) → le_out_ga
U9_gga(X, app_out_gga(Zs)) → app_out_gga(.(X, Zs))
The set Q consists of the following terms:
part_in_aaaa
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1)
le_in_gg(x0, x1)
U8_ggaa(x0, x1)
U4_ga(x0)
gt_in_ga(x0)
U6_gaaa(x0, x1)
le_in_ga(x0)
U8_gaaa(x0)
U10_gg(x0)
U11_gg(x0)
app_in_gga(x0, x1)
U10_ga(x0)
U11_ga(x0)
U9_gga(x0, x1)
We have to consider all (P,Q,R)-chains.
(118) UsableRulesProof (EQUIVALENT transformation)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
(119) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_AA(part_out_aaaa(Littles)) → U2_AA(qs_in_ga(Littles))
U2_AA(qs_out_ga(Ls)) → QS_IN_AA
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
The TRS R consists of the following rules:
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa([])
U8_aaaa(part_out_gaaa(Ls)) → part_out_aaaa(Ls)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U7_gaaa(X, le_out_ga) → U8_gaaa(part_in_gaaa(X))
U8_gaaa(part_out_gaaa(Ls)) → part_out_gaaa(Ls)
U11_ga(le_out_ga) → le_out_ga
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
U5_gaaa(X, gt_out_ga(Y)) → U6_gaaa(Y, part_in_gaaa(X))
U6_gaaa(Y, part_out_gaaa(Ls)) → part_out_gaaa(.(Y, Ls))
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U6_aaaa(Y, part_out_gaaa(Ls)) → part_out_aaaa(.(Y, Ls))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
qs_in_ga(.(X, Xs)) → U1_ga(X, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa([], [])
U1_ga(X, part_out_ggaa(Littles, Bigs)) → U2_ga(X, Bigs, qs_in_ga(Littles))
U2_ga(X, Bigs, qs_out_ga(Ls)) → U3_ga(X, Ls, qs_in_ga(Bigs))
U3_ga(X, Ls, qs_out_ga(Bs)) → U4_ga(app_in_gga(Ls, .(X, Bs)))
app_in_gga(.(X, Xs), Ys) → U9_gga(X, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga(Ys)
U4_ga(app_out_gga(Ys)) → qs_out_ga(Ys)
U9_gga(X, app_out_gga(Zs)) → app_out_gga(.(X, Zs))
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U7_ggaa(X, Y, Xs, le_out_gg) → U8_ggaa(Y, part_in_ggaa(X, Xs))
U8_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(Ls, .(Y, Bs))
U11_gg(le_out_gg) → le_out_gg
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
U5_ggaa(X, Y, Xs, gt_out_gg) → U6_ggaa(Y, part_in_ggaa(X, Xs))
U6_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(.(Y, Ls), Bs)
U10_gg(gt_out_gg) → gt_out_gg
The set Q consists of the following terms:
part_in_aaaa
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1)
le_in_gg(x0, x1)
U8_ggaa(x0, x1)
U4_ga(x0)
gt_in_ga(x0)
U6_gaaa(x0, x1)
le_in_ga(x0)
U8_gaaa(x0)
U10_gg(x0)
U11_gg(x0)
app_in_gga(x0, x1)
U10_ga(x0)
U11_ga(x0)
U9_gga(x0, x1)
We have to consider all (P,Q,R)-chains.
(120) QReductionProof (EQUIVALENT transformation)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
part_in_aaaa
(121) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_AA(part_out_aaaa(Littles)) → U2_AA(qs_in_ga(Littles))
U2_AA(qs_out_ga(Ls)) → QS_IN_AA
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
The TRS R consists of the following rules:
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa([])
U8_aaaa(part_out_gaaa(Ls)) → part_out_aaaa(Ls)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U7_gaaa(X, le_out_ga) → U8_gaaa(part_in_gaaa(X))
U8_gaaa(part_out_gaaa(Ls)) → part_out_gaaa(Ls)
U11_ga(le_out_ga) → le_out_ga
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
U5_gaaa(X, gt_out_ga(Y)) → U6_gaaa(Y, part_in_gaaa(X))
U6_gaaa(Y, part_out_gaaa(Ls)) → part_out_gaaa(.(Y, Ls))
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U6_aaaa(Y, part_out_gaaa(Ls)) → part_out_aaaa(.(Y, Ls))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
qs_in_ga(.(X, Xs)) → U1_ga(X, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa([], [])
U1_ga(X, part_out_ggaa(Littles, Bigs)) → U2_ga(X, Bigs, qs_in_ga(Littles))
U2_ga(X, Bigs, qs_out_ga(Ls)) → U3_ga(X, Ls, qs_in_ga(Bigs))
U3_ga(X, Ls, qs_out_ga(Bs)) → U4_ga(app_in_gga(Ls, .(X, Bs)))
app_in_gga(.(X, Xs), Ys) → U9_gga(X, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga(Ys)
U4_ga(app_out_gga(Ys)) → qs_out_ga(Ys)
U9_gga(X, app_out_gga(Zs)) → app_out_gga(.(X, Zs))
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U7_ggaa(X, Y, Xs, le_out_gg) → U8_ggaa(Y, part_in_ggaa(X, Xs))
U8_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(Ls, .(Y, Bs))
U11_gg(le_out_gg) → le_out_gg
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
U5_ggaa(X, Y, Xs, gt_out_gg) → U6_ggaa(Y, part_in_ggaa(X, Xs))
U6_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(.(Y, Ls), Bs)
U10_gg(gt_out_gg) → gt_out_gg
The set Q consists of the following terms:
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1)
le_in_gg(x0, x1)
U8_ggaa(x0, x1)
U4_ga(x0)
gt_in_ga(x0)
U6_gaaa(x0, x1)
le_in_ga(x0)
U8_gaaa(x0)
U10_gg(x0)
U11_gg(x0)
app_in_gga(x0, x1)
U10_ga(x0)
U11_ga(x0)
U9_gga(x0, x1)
We have to consider all (P,Q,R)-chains.
(122) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
U1_AA(
part_out_aaaa(
Littles)) →
U2_AA(
qs_in_ga(
Littles)) at position [0] we obtained the following new rules [LPAR04]:
U1_AA(part_out_aaaa(.(x0, x1))) → U2_AA(U1_ga(x0, part_in_ggaa(x0, x1)))
U1_AA(part_out_aaaa([])) → U2_AA(qs_out_ga([]))
(123) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U2_AA(qs_out_ga(Ls)) → QS_IN_AA
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
U1_AA(part_out_aaaa(.(x0, x1))) → U2_AA(U1_ga(x0, part_in_ggaa(x0, x1)))
U1_AA(part_out_aaaa([])) → U2_AA(qs_out_ga([]))
The TRS R consists of the following rules:
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa([])
U8_aaaa(part_out_gaaa(Ls)) → part_out_aaaa(Ls)
le_in_ga(s(X)) → U11_ga(le_in_ga(X))
le_in_ga(0) → le_out_ga
U7_gaaa(X, le_out_ga) → U8_gaaa(part_in_gaaa(X))
U8_gaaa(part_out_gaaa(Ls)) → part_out_gaaa(Ls)
U11_ga(le_out_ga) → le_out_ga
gt_in_ga(s(X)) → U10_ga(gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(0)
U5_gaaa(X, gt_out_ga(Y)) → U6_gaaa(Y, part_in_gaaa(X))
U6_gaaa(Y, part_out_gaaa(Ls)) → part_out_gaaa(.(Y, Ls))
U10_ga(gt_out_ga(Y)) → gt_out_ga(s(Y))
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U6_aaaa(Y, part_out_gaaa(Ls)) → part_out_aaaa(.(Y, Ls))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
qs_in_ga(.(X, Xs)) → U1_ga(X, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa([], [])
U1_ga(X, part_out_ggaa(Littles, Bigs)) → U2_ga(X, Bigs, qs_in_ga(Littles))
U2_ga(X, Bigs, qs_out_ga(Ls)) → U3_ga(X, Ls, qs_in_ga(Bigs))
U3_ga(X, Ls, qs_out_ga(Bs)) → U4_ga(app_in_gga(Ls, .(X, Bs)))
app_in_gga(.(X, Xs), Ys) → U9_gga(X, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga(Ys)
U4_ga(app_out_gga(Ys)) → qs_out_ga(Ys)
U9_gga(X, app_out_gga(Zs)) → app_out_gga(.(X, Zs))
le_in_gg(s(X), s(Y)) → U11_gg(le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg
le_in_gg(0, 0) → le_out_gg
U7_ggaa(X, Y, Xs, le_out_gg) → U8_ggaa(Y, part_in_ggaa(X, Xs))
U8_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(Ls, .(Y, Bs))
U11_gg(le_out_gg) → le_out_gg
gt_in_gg(s(X), s(Y)) → U10_gg(gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg
U5_ggaa(X, Y, Xs, gt_out_gg) → U6_ggaa(Y, part_in_ggaa(X, Xs))
U6_ggaa(Y, part_out_ggaa(Ls, Bs)) → part_out_ggaa(.(Y, Ls), Bs)
U10_gg(gt_out_gg) → gt_out_gg
The set Q consists of the following terms:
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1)
le_in_gg(x0, x1)
U8_ggaa(x0, x1)
U4_ga(x0)
gt_in_ga(x0)
U6_gaaa(x0, x1)
le_in_ga(x0)
U8_gaaa(x0)
U10_gg(x0)
U11_gg(x0)
app_in_gga(x0, x1)
U10_ga(x0)
U11_ga(x0)
U9_gga(x0, x1)
We have to consider all (P,Q,R)-chains.
(124) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:
s =
QS_IN_AA evaluates to t =
QS_IN_AAThus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Matcher: [ ]
- Semiunifier: [ ]
Rewriting sequenceQS_IN_AA →
U1_AA(
part_out_aaaa(
[]))
with rule
QS_IN_AA →
U1_AA(
part_out_aaaa(
[])) at position [] and matcher [ ]
U1_AA(part_out_aaaa([])) →
U2_AA(
qs_out_ga(
[]))
with rule
U1_AA(
part_out_aaaa(
[])) →
U2_AA(
qs_out_ga(
[])) at position [] and matcher [ ]
U2_AA(qs_out_ga([])) →
QS_IN_AAwith rule
U2_AA(
qs_out_ga(
Ls)) →
QS_IN_AANow applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence
All these steps are and every following step will be a correct step w.r.t to Q.
(125) FALSE
(126) PrologToPiTRSProof (SOUND transformation)
We use the technique of [LOPSTR]. With regard to the inferred argument filtering the predicates were used in the following modes:
qs_in: (f,b) (b,f) (f,f)
part_in: (f,f,f,f) (b,f,f,f) (b,b,f,f)
gt_in: (f,f) (b,f) (b,b)
le_in: (b,f) (f,f) (b,b)
app_in: (b,b,f) (b,f,f) (b,f,b)
Transforming
Prolog into the following
Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog
(127) Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
(128) 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:
QS_IN_AG(.(X, Xs), Ys) → U1_AG(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
QS_IN_AG(.(X, Xs), Ys) → PART_IN_AAAA(X, Xs, Littles, Bigs)
PART_IN_AAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_AAAA(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
PART_IN_AAAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_AA(X, Y)
GT_IN_AA(s(X), s(Y)) → U10_AA(X, Y, gt_in_aa(X, Y))
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
U5_AAAA(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_AAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U5_AAAA(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GAAA(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_GA(X, Y)
GT_IN_GA(s(X), s(Y)) → U10_GA(X, Y, gt_in_ga(X, Y))
GT_IN_GA(s(X), s(Y)) → GT_IN_GA(X, Y)
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_GAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GAAA(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_GA(X, Y)
LE_IN_GA(s(X), s(Y)) → U11_GA(X, Y, le_in_ga(X, Y))
LE_IN_GA(s(X), s(Y)) → LE_IN_GA(X, Y)
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_GAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_AAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_AAAA(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
PART_IN_AAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_AA(X, Y)
LE_IN_AA(s(X), s(Y)) → U11_AA(X, Y, le_in_aa(X, Y))
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
U7_AAAA(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_AAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_AAAA(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
U1_AG(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AG(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_AG(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
QS_IN_GA(.(X, Xs), Ys) → U1_GA(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
QS_IN_GA(.(X, Xs), Ys) → PART_IN_GGAA(X, Xs, Littles, Bigs)
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GGAA(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_GG(X, Y)
GT_IN_GG(s(X), s(Y)) → U10_GG(X, Y, gt_in_gg(X, Y))
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_GGAA(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GGAA(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_GG(X, Y)
LE_IN_GG(s(X), s(Y)) → U11_GG(X, Y, le_in_gg(X, Y))
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_GGAA(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_GA(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs, Bs)
U3_GA(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_GA(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
U3_GA(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → APP_IN_GGA(Ls, .(X, Bs), Ys)
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → U9_GGA(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GGA(Xs, Ys, Zs)
U2_AG(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_AG(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
U2_AG(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
QS_IN_AA(.(X, Xs), Ys) → U1_AA(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
QS_IN_AA(.(X, Xs), Ys) → PART_IN_AAAA(X, Xs, Littles, Bigs)
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_AA(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
U3_AA(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_AA(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
U3_AA(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → APP_IN_GAA(Ls, .(X, Bs), Ys)
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → U9_GAA(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAA(Xs, Ys, Zs)
U3_AG(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_AG(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
U3_AG(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → APP_IN_GAG(Ls, .(X, Bs), Ys)
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → U9_GAG(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAG(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
QS_IN_AG(
x1,
x2) =
QS_IN_AG(
x2)
U1_AG(
x1,
x2,
x3,
x4) =
U1_AG(
x3,
x4)
PART_IN_AAAA(
x1,
x2,
x3,
x4) =
PART_IN_AAAA
U5_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_AAAA(
x6)
GT_IN_AA(
x1,
x2) =
GT_IN_AA
U10_AA(
x1,
x2,
x3) =
U10_AA(
x3)
U6_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_AAAA(
x2,
x6)
PART_IN_GAAA(
x1,
x2,
x3,
x4) =
PART_IN_GAAA(
x1)
U5_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GAAA(
x1,
x6)
GT_IN_GA(
x1,
x2) =
GT_IN_GA(
x1)
U10_GA(
x1,
x2,
x3) =
U10_GA(
x1,
x3)
U6_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_GAAA(
x1,
x2,
x6)
U7_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GAAA(
x1,
x6)
LE_IN_GA(
x1,
x2) =
LE_IN_GA(
x1)
U11_GA(
x1,
x2,
x3) =
U11_GA(
x1,
x3)
U8_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_GAAA(
x1,
x6)
U7_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_AAAA(
x6)
LE_IN_AA(
x1,
x2) =
LE_IN_AA
U11_AA(
x1,
x2,
x3) =
U11_AA(
x3)
U8_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_AAAA(
x6)
U2_AG(
x1,
x2,
x3,
x4,
x5) =
U2_AG(
x3,
x5)
QS_IN_GA(
x1,
x2) =
QS_IN_GA(
x1)
U1_GA(
x1,
x2,
x3,
x4) =
U1_GA(
x1,
x2,
x4)
PART_IN_GGAA(
x1,
x2,
x3,
x4) =
PART_IN_GGAA(
x1,
x2)
U5_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GGAA(
x1,
x2,
x3,
x6)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
U10_GG(
x1,
x2,
x3) =
U10_GG(
x1,
x2,
x3)
U6_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_GGAA(
x1,
x2,
x3,
x6)
U7_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GGAA(
x1,
x2,
x3,
x6)
LE_IN_GG(
x1,
x2) =
LE_IN_GG(
x1,
x2)
U11_GG(
x1,
x2,
x3) =
U11_GG(
x1,
x2,
x3)
U8_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_GGAA(
x1,
x2,
x3,
x6)
U2_GA(
x1,
x2,
x3,
x4,
x5) =
U2_GA(
x1,
x2,
x4,
x5)
U3_GA(
x1,
x2,
x3,
x4,
x5) =
U3_GA(
x1,
x2,
x4,
x5)
U4_GA(
x1,
x2,
x3,
x4) =
U4_GA(
x1,
x2,
x4)
APP_IN_GGA(
x1,
x2,
x3) =
APP_IN_GGA(
x1,
x2)
U9_GGA(
x1,
x2,
x3,
x4,
x5) =
U9_GGA(
x1,
x2,
x3,
x5)
U3_AG(
x1,
x2,
x3,
x4,
x5) =
U3_AG(
x3,
x4,
x5)
QS_IN_AA(
x1,
x2) =
QS_IN_AA
U1_AA(
x1,
x2,
x3,
x4) =
U1_AA(
x4)
U2_AA(
x1,
x2,
x3,
x4,
x5) =
U2_AA(
x5)
U3_AA(
x1,
x2,
x3,
x4,
x5) =
U3_AA(
x4,
x5)
U4_AA(
x1,
x2,
x3,
x4) =
U4_AA(
x4)
APP_IN_GAA(
x1,
x2,
x3) =
APP_IN_GAA(
x1)
U9_GAA(
x1,
x2,
x3,
x4,
x5) =
U9_GAA(
x1,
x2,
x5)
U4_AG(
x1,
x2,
x3,
x4) =
U4_AG(
x3,
x4)
APP_IN_GAG(
x1,
x2,
x3) =
APP_IN_GAG(
x1,
x3)
U9_GAG(
x1,
x2,
x3,
x4,
x5) =
U9_GAG(
x1,
x2,
x4,
x5)
We have to consider all (P,R,Pi)-chains
(129) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
QS_IN_AG(.(X, Xs), Ys) → U1_AG(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
QS_IN_AG(.(X, Xs), Ys) → PART_IN_AAAA(X, Xs, Littles, Bigs)
PART_IN_AAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_AAAA(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
PART_IN_AAAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_AA(X, Y)
GT_IN_AA(s(X), s(Y)) → U10_AA(X, Y, gt_in_aa(X, Y))
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
U5_AAAA(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_AAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U5_AAAA(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GAAA(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_GA(X, Y)
GT_IN_GA(s(X), s(Y)) → U10_GA(X, Y, gt_in_ga(X, Y))
GT_IN_GA(s(X), s(Y)) → GT_IN_GA(X, Y)
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_GAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GAAA(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_GA(X, Y)
LE_IN_GA(s(X), s(Y)) → U11_GA(X, Y, le_in_ga(X, Y))
LE_IN_GA(s(X), s(Y)) → LE_IN_GA(X, Y)
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_GAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_AAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_AAAA(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
PART_IN_AAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_AA(X, Y)
LE_IN_AA(s(X), s(Y)) → U11_AA(X, Y, le_in_aa(X, Y))
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
U7_AAAA(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_AAAA(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_AAAA(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
U1_AG(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AG(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_AG(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
QS_IN_GA(.(X, Xs), Ys) → U1_GA(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
QS_IN_GA(.(X, Xs), Ys) → PART_IN_GGAA(X, Xs, Littles, Bigs)
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GGAA(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → GT_IN_GG(X, Y)
GT_IN_GG(s(X), s(Y)) → U10_GG(X, Y, gt_in_gg(X, Y))
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_GGAA(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GGAA(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → LE_IN_GG(X, Y)
LE_IN_GG(s(X), s(Y)) → U11_GG(X, Y, le_in_gg(X, Y))
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_GGAA(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_GA(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs, Bs)
U3_GA(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_GA(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
U3_GA(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → APP_IN_GGA(Ls, .(X, Bs), Ys)
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → U9_GGA(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GGA(Xs, Ys, Zs)
U2_AG(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_AG(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
U2_AG(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
QS_IN_AA(.(X, Xs), Ys) → U1_AA(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
QS_IN_AA(.(X, Xs), Ys) → PART_IN_AAAA(X, Xs, Littles, Bigs)
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_AA(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
U3_AA(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_AA(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
U3_AA(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → APP_IN_GAA(Ls, .(X, Bs), Ys)
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → U9_GAA(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAA(Xs, Ys, Zs)
U3_AG(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_AG(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
U3_AG(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → APP_IN_GAG(Ls, .(X, Bs), Ys)
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → U9_GAG(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAG(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
QS_IN_AG(
x1,
x2) =
QS_IN_AG(
x2)
U1_AG(
x1,
x2,
x3,
x4) =
U1_AG(
x3,
x4)
PART_IN_AAAA(
x1,
x2,
x3,
x4) =
PART_IN_AAAA
U5_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_AAAA(
x6)
GT_IN_AA(
x1,
x2) =
GT_IN_AA
U10_AA(
x1,
x2,
x3) =
U10_AA(
x3)
U6_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_AAAA(
x2,
x6)
PART_IN_GAAA(
x1,
x2,
x3,
x4) =
PART_IN_GAAA(
x1)
U5_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GAAA(
x1,
x6)
GT_IN_GA(
x1,
x2) =
GT_IN_GA(
x1)
U10_GA(
x1,
x2,
x3) =
U10_GA(
x1,
x3)
U6_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_GAAA(
x1,
x2,
x6)
U7_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GAAA(
x1,
x6)
LE_IN_GA(
x1,
x2) =
LE_IN_GA(
x1)
U11_GA(
x1,
x2,
x3) =
U11_GA(
x1,
x3)
U8_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_GAAA(
x1,
x6)
U7_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_AAAA(
x6)
LE_IN_AA(
x1,
x2) =
LE_IN_AA
U11_AA(
x1,
x2,
x3) =
U11_AA(
x3)
U8_AAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_AAAA(
x6)
U2_AG(
x1,
x2,
x3,
x4,
x5) =
U2_AG(
x3,
x5)
QS_IN_GA(
x1,
x2) =
QS_IN_GA(
x1)
U1_GA(
x1,
x2,
x3,
x4) =
U1_GA(
x1,
x2,
x4)
PART_IN_GGAA(
x1,
x2,
x3,
x4) =
PART_IN_GGAA(
x1,
x2)
U5_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GGAA(
x1,
x2,
x3,
x6)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
U10_GG(
x1,
x2,
x3) =
U10_GG(
x1,
x2,
x3)
U6_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_GGAA(
x1,
x2,
x3,
x6)
U7_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GGAA(
x1,
x2,
x3,
x6)
LE_IN_GG(
x1,
x2) =
LE_IN_GG(
x1,
x2)
U11_GG(
x1,
x2,
x3) =
U11_GG(
x1,
x2,
x3)
U8_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_GGAA(
x1,
x2,
x3,
x6)
U2_GA(
x1,
x2,
x3,
x4,
x5) =
U2_GA(
x1,
x2,
x4,
x5)
U3_GA(
x1,
x2,
x3,
x4,
x5) =
U3_GA(
x1,
x2,
x4,
x5)
U4_GA(
x1,
x2,
x3,
x4) =
U4_GA(
x1,
x2,
x4)
APP_IN_GGA(
x1,
x2,
x3) =
APP_IN_GGA(
x1,
x2)
U9_GGA(
x1,
x2,
x3,
x4,
x5) =
U9_GGA(
x1,
x2,
x3,
x5)
U3_AG(
x1,
x2,
x3,
x4,
x5) =
U3_AG(
x3,
x4,
x5)
QS_IN_AA(
x1,
x2) =
QS_IN_AA
U1_AA(
x1,
x2,
x3,
x4) =
U1_AA(
x4)
U2_AA(
x1,
x2,
x3,
x4,
x5) =
U2_AA(
x5)
U3_AA(
x1,
x2,
x3,
x4,
x5) =
U3_AA(
x4,
x5)
U4_AA(
x1,
x2,
x3,
x4) =
U4_AA(
x4)
APP_IN_GAA(
x1,
x2,
x3) =
APP_IN_GAA(
x1)
U9_GAA(
x1,
x2,
x3,
x4,
x5) =
U9_GAA(
x1,
x2,
x5)
U4_AG(
x1,
x2,
x3,
x4) =
U4_AG(
x3,
x4)
APP_IN_GAG(
x1,
x2,
x3) =
APP_IN_GAG(
x1,
x3)
U9_GAG(
x1,
x2,
x3,
x4,
x5) =
U9_GAG(
x1,
x2,
x4,
x5)
We have to consider all (P,R,Pi)-chains
(130) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LOPSTR] contains 13 SCCs with 42 less nodes.
(131) Complex Obligation (AND)
(132) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAG(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
APP_IN_GAG(
x1,
x2,
x3) =
APP_IN_GAG(
x1,
x3)
We have to consider all (P,R,Pi)-chains
(133) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(134) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GAG(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAG(Xs, Ys, Zs)
R is empty.
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
APP_IN_GAG(
x1,
x2,
x3) =
APP_IN_GAG(
x1,
x3)
We have to consider all (P,R,Pi)-chains
(135) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(136) Obligation:
Q DP problem:
The TRS P consists of the following rules:
APP_IN_GAG(.(X, Xs), .(X, Zs)) → APP_IN_GAG(Xs, Zs)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(137) 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:
- APP_IN_GAG(.(X, Xs), .(X, Zs)) → APP_IN_GAG(Xs, Zs)
The graph contains the following edges 1 > 1, 2 > 2
(138) TRUE
(139) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAA(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
APP_IN_GAA(
x1,
x2,
x3) =
APP_IN_GAA(
x1)
We have to consider all (P,R,Pi)-chains
(140) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(141) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GAA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GAA(Xs, Ys, Zs)
R is empty.
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
APP_IN_GAA(
x1,
x2,
x3) =
APP_IN_GAA(
x1)
We have to consider all (P,R,Pi)-chains
(142) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(143) Obligation:
Q DP problem:
The TRS P consists of the following rules:
APP_IN_GAA(.(X, Xs)) → APP_IN_GAA(Xs)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(144) 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:
- APP_IN_GAA(.(X, Xs)) → APP_IN_GAA(Xs)
The graph contains the following edges 1 > 1
(145) TRUE
(146) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GGA(Xs, Ys, Zs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
APP_IN_GGA(
x1,
x2,
x3) =
APP_IN_GGA(
x1,
x2)
We have to consider all (P,R,Pi)-chains
(147) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(148) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
APP_IN_GGA(.(X, Xs), Ys, .(X, Zs)) → APP_IN_GGA(Xs, Ys, Zs)
R is empty.
The argument filtering Pi contains the following mapping:
.(
x1,
x2) =
.(
x1,
x2)
APP_IN_GGA(
x1,
x2,
x3) =
APP_IN_GGA(
x1,
x2)
We have to consider all (P,R,Pi)-chains
(149) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(150) Obligation:
Q DP problem:
The TRS P consists of the following rules:
APP_IN_GGA(.(X, Xs), Ys) → APP_IN_GGA(Xs, Ys)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(151) 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:
- APP_IN_GGA(.(X, Xs), Ys) → APP_IN_GGA(Xs, Ys)
The graph contains the following edges 1 > 1, 2 >= 2
(152) TRUE
(153) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
LE_IN_GG(
x1,
x2) =
LE_IN_GG(
x1,
x2)
We have to consider all (P,R,Pi)-chains
(154) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(155) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
(156) PiDPToQDPProof (EQUIVALENT transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(157) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(158) 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:
- LE_IN_GG(s(X), s(Y)) → LE_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2
(159) TRUE
(160) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
GT_IN_GG(
x1,
x2) =
GT_IN_GG(
x1,
x2)
We have to consider all (P,R,Pi)-chains
(161) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(162) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
(163) PiDPToQDPProof (EQUIVALENT transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(164) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(165) 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:
- GT_IN_GG(s(X), s(Y)) → GT_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2
(166) TRUE
(167) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GGAA(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GGAA(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
PART_IN_GGAA(
x1,
x2,
x3,
x4) =
PART_IN_GGAA(
x1,
x2)
U5_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GGAA(
x1,
x2,
x3,
x6)
U7_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GGAA(
x1,
x2,
x3,
x6)
We have to consider all (P,R,Pi)-chains
(168) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(169) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U5_GGAA(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
PART_IN_GGAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GGAA(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GGAA(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
U7_GGAA(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs, Ls, Bs)
The TRS R consists of the following rules:
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
0 =
0
.(
x1,
x2) =
.(
x1,
x2)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
PART_IN_GGAA(
x1,
x2,
x3,
x4) =
PART_IN_GGAA(
x1,
x2)
U5_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GGAA(
x1,
x2,
x3,
x6)
U7_GGAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GGAA(
x1,
x2,
x3,
x6)
We have to consider all (P,R,Pi)-chains
(170) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(171) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GGAA(X, Y, Xs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs)
PART_IN_GGAA(X, .(Y, Xs)) → U5_GGAA(X, Y, Xs, gt_in_gg(X, Y))
PART_IN_GGAA(X, .(Y, Xs)) → U7_GGAA(X, Y, Xs, le_in_gg(X, Y))
U7_GGAA(X, Y, Xs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs)
The TRS R consists of the following rules:
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
The set Q consists of the following terms:
gt_in_gg(x0, x1)
le_in_gg(x0, x1)
U10_gg(x0, x1, x2)
U11_gg(x0, x1, x2)
We have to consider all (P,Q,R)-chains.
(172) 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:
- PART_IN_GGAA(X, .(Y, Xs)) → U5_GGAA(X, Y, Xs, gt_in_gg(X, Y))
The graph contains the following edges 1 >= 1, 2 > 2, 2 > 3
- PART_IN_GGAA(X, .(Y, Xs)) → U7_GGAA(X, Y, Xs, le_in_gg(X, Y))
The graph contains the following edges 1 >= 1, 2 > 2, 2 > 3
- U5_GGAA(X, Y, Xs, gt_out_gg(X, Y)) → PART_IN_GGAA(X, Xs)
The graph contains the following edges 1 >= 1, 4 > 1, 3 >= 2
- U7_GGAA(X, Y, Xs, le_out_gg(X, Y)) → PART_IN_GGAA(X, Xs)
The graph contains the following edges 1 >= 1, 4 > 1, 3 >= 2
(173) TRUE
(174) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs, Bs)
QS_IN_GA(.(X, Xs), Ys) → U1_GA(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
QS_IN_GA(
x1,
x2) =
QS_IN_GA(
x1)
U1_GA(
x1,
x2,
x3,
x4) =
U1_GA(
x1,
x2,
x4)
U2_GA(
x1,
x2,
x3,
x4,
x5) =
U2_GA(
x1,
x2,
x4,
x5)
We have to consider all (P,R,Pi)-chains
(175) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(176) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_GA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs, Bs)
QS_IN_GA(.(X, Xs), Ys) → U1_GA(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
U1_GA(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles, Ls)
The TRS R consists of the following rules:
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
qs_in_ga([], []) → qs_out_ga([], [])
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
0 =
0
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
QS_IN_GA(
x1,
x2) =
QS_IN_GA(
x1)
U1_GA(
x1,
x2,
x3,
x4) =
U1_GA(
x1,
x2,
x4)
U2_GA(
x1,
x2,
x3,
x4,
x5) =
U2_GA(
x1,
x2,
x4,
x5)
We have to consider all (P,R,Pi)-chains
(177) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(178) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_GA(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Bigs, qs_in_ga(Littles))
U2_GA(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs)
QS_IN_GA(.(X, Xs)) → U1_GA(X, Xs, part_in_ggaa(X, Xs))
U1_GA(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles)
The TRS R consists of the following rules:
qs_in_ga(.(X, Xs)) → U1_ga(X, Xs, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([], [])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa(X, [], [], [])
U1_ga(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Bigs, qs_in_ga(Littles))
U5_ggaa(X, Y, Xs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U7_ggaa(X, Y, Xs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U2_ga(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ls, qs_in_ga(Bigs))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U6_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U8_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U3_ga(X, Xs, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, app_in_gga(Ls, .(X, Bs)))
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U4_ga(X, Xs, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
app_in_gga(.(X, Xs), Ys) → U9_gga(X, Xs, Ys, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
The set Q consists of the following terms:
qs_in_ga(x0)
part_in_ggaa(x0, x1)
U1_ga(x0, x1, x2)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U2_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1, x2, x3)
le_in_gg(x0, x1)
U8_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2, x3)
U10_gg(x0, x1, x2)
U11_gg(x0, x1, x2)
U4_ga(x0, x1, x2)
app_in_gga(x0, x1)
U9_gga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(179) QDPOrderProof (EQUIVALENT transformation)
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
QS_IN_GA(.(X, Xs)) → U1_GA(X, Xs, part_in_ggaa(X, Xs))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:
POL(.(x1, x2)) = 1 + x2
POL(0) = 0
POL(QS_IN_GA(x1)) = x1
POL(U10_gg(x1, x2, x3)) = 0
POL(U11_gg(x1, x2, x3)) = 0
POL(U1_GA(x1, x2, x3)) = x3
POL(U1_ga(x1, x2, x3)) = 0
POL(U2_GA(x1, x2, x3, x4)) = x3
POL(U2_ga(x1, x2, x3, x4)) = 0
POL(U3_ga(x1, x2, x3, x4)) = 0
POL(U4_ga(x1, x2, x3)) = 0
POL(U5_ggaa(x1, x2, x3, x4)) = 1 + x3
POL(U6_ggaa(x1, x2, x3, x4)) = 1 + x4
POL(U7_ggaa(x1, x2, x3, x4)) = 1 + x3
POL(U8_ggaa(x1, x2, x3, x4)) = 1 + x4
POL(U9_gga(x1, x2, x3, x4)) = 0
POL([]) = 0
POL(app_in_gga(x1, x2)) = 0
POL(app_out_gga(x1, x2, x3)) = 0
POL(gt_in_gg(x1, x2)) = 0
POL(gt_out_gg(x1, x2)) = 0
POL(le_in_gg(x1, x2)) = 0
POL(le_out_gg(x1, x2)) = 0
POL(part_in_ggaa(x1, x2)) = x2
POL(part_out_ggaa(x1, x2, x3, x4)) = x3 + x4
POL(qs_in_ga(x1)) = 0
POL(qs_out_ga(x1, x2)) = 0
POL(s(x1)) = 0
The following usable rules [FROCOS05] were oriented:
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa(X, [], [], [])
U5_ggaa(X, Y, Xs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U6_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U7_ggaa(X, Y, Xs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U8_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
(180) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_GA(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_GA(X, Xs, Bigs, qs_in_ga(Littles))
U2_GA(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_GA(Bigs)
U1_GA(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → QS_IN_GA(Littles)
The TRS R consists of the following rules:
qs_in_ga(.(X, Xs)) → U1_ga(X, Xs, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([], [])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa(X, [], [], [])
U1_ga(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Bigs, qs_in_ga(Littles))
U5_ggaa(X, Y, Xs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U7_ggaa(X, Y, Xs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U2_ga(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ls, qs_in_ga(Bigs))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U6_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U8_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U3_ga(X, Xs, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, app_in_gga(Ls, .(X, Bs)))
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U4_ga(X, Xs, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
app_in_gga(.(X, Xs), Ys) → U9_gga(X, Xs, Ys, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
The set Q consists of the following terms:
qs_in_ga(x0)
part_in_ggaa(x0, x1)
U1_ga(x0, x1, x2)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U2_ga(x0, x1, x2, x3)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1, x2, x3)
le_in_gg(x0, x1)
U8_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2, x3)
U10_gg(x0, x1, x2)
U11_gg(x0, x1, x2)
U4_ga(x0, x1, x2)
app_in_gga(x0, x1)
U9_gga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(181) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.
(182) TRUE
(183) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
LE_IN_AA(
x1,
x2) =
LE_IN_AA
We have to consider all (P,R,Pi)-chains
(184) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(185) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
R is empty.
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
LE_IN_AA(
x1,
x2) =
LE_IN_AA
We have to consider all (P,R,Pi)-chains
(186) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(187) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LE_IN_AA → LE_IN_AA
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(188) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.
s =
LE_IN_AA evaluates to t =
LE_IN_AAThus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Semiunifier: [ ]
- Matcher: [ ]
Rewriting sequenceThe DP semiunifies directly so there is only one rewrite step from LE_IN_AA to LE_IN_AA.
(189) FALSE
(190) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_GA(s(X), s(Y)) → LE_IN_GA(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
LE_IN_GA(
x1,
x2) =
LE_IN_GA(
x1)
We have to consider all (P,R,Pi)-chains
(191) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(192) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
LE_IN_GA(s(X), s(Y)) → LE_IN_GA(X, Y)
R is empty.
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
LE_IN_GA(
x1,
x2) =
LE_IN_GA(
x1)
We have to consider all (P,R,Pi)-chains
(193) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(194) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LE_IN_GA(s(X)) → LE_IN_GA(X)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(195) 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:
- LE_IN_GA(s(X)) → LE_IN_GA(X)
The graph contains the following edges 1 > 1
(196) TRUE
(197) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_GA(s(X), s(Y)) → GT_IN_GA(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
GT_IN_GA(
x1,
x2) =
GT_IN_GA(
x1)
We have to consider all (P,R,Pi)-chains
(198) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(199) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_GA(s(X), s(Y)) → GT_IN_GA(X, Y)
R is empty.
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
GT_IN_GA(
x1,
x2) =
GT_IN_GA(
x1)
We have to consider all (P,R,Pi)-chains
(200) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(201) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT_IN_GA(s(X)) → GT_IN_GA(X)
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(202) 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:
- GT_IN_GA(s(X)) → GT_IN_GA(X)
The graph contains the following edges 1 > 1
(203) TRUE
(204) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GAAA(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GAAA(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
PART_IN_GAAA(
x1,
x2,
x3,
x4) =
PART_IN_GAAA(
x1)
U5_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GAAA(
x1,
x6)
U7_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GAAA(
x1,
x6)
We have to consider all (P,R,Pi)-chains
(205) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(206) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
PART_IN_GAAA(X, .(Y, Xs), .(Y, Ls), Bs) → U5_GAAA(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
PART_IN_GAAA(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_GAAA(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
U7_GAAA(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → PART_IN_GAAA(X, Xs, Ls, Bs)
The TRS R consists of the following rules:
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
The argument filtering Pi contains the following mapping:
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
PART_IN_GAAA(
x1,
x2,
x3,
x4) =
PART_IN_GAAA(
x1)
U5_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_GAAA(
x1,
x6)
U7_GAAA(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_GAAA(
x1,
x6)
We have to consider all (P,R,Pi)-chains
(207) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(208) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, gt_out_ga(X, Y)) → PART_IN_GAAA(X)
PART_IN_GAAA(X) → U5_GAAA(X, gt_in_ga(X))
PART_IN_GAAA(X) → U7_GAAA(X, le_in_ga(X))
U7_GAAA(X, le_out_ga(X)) → PART_IN_GAAA(X)
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
We have to consider all (P,Q,R)-chains.
(209) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
PART_IN_GAAA(
X) →
U5_GAAA(
X,
gt_in_ga(
X)) at position [1] we obtained the following new rules [LPAR04]:
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(x0, gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(s(0), 0))
(210) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, gt_out_ga(X, Y)) → PART_IN_GAAA(X)
PART_IN_GAAA(X) → U7_GAAA(X, le_in_ga(X))
U7_GAAA(X, le_out_ga(X)) → PART_IN_GAAA(X)
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(x0, gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(s(0), 0))
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
We have to consider all (P,Q,R)-chains.
(211) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
PART_IN_GAAA(
X) →
U7_GAAA(
X,
le_in_ga(
X)) at position [1] we obtained the following new rules [LPAR04]:
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(x0, le_in_ga(x0)))
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga(0))
(212) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GAAA(X, gt_out_ga(X, Y)) → PART_IN_GAAA(X)
U7_GAAA(X, le_out_ga(X)) → PART_IN_GAAA(X)
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(x0, gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(s(0), 0))
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(x0, le_in_ga(x0)))
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga(0))
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
We have to consider all (P,Q,R)-chains.
(213) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U5_GAAA(
X,
gt_out_ga(
X,
Y)) →
PART_IN_GAAA(
X) we obtained the following new rules [LPAR04]:
U5_GAAA(s(z0), gt_out_ga(s(z0), x1)) → PART_IN_GAAA(s(z0))
U5_GAAA(s(0), gt_out_ga(s(0), 0)) → PART_IN_GAAA(s(0))
(214) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U7_GAAA(X, le_out_ga(X)) → PART_IN_GAAA(X)
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(x0, gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(s(0), 0))
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(x0, le_in_ga(x0)))
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga(0))
U5_GAAA(s(z0), gt_out_ga(s(z0), x1)) → PART_IN_GAAA(s(z0))
U5_GAAA(s(0), gt_out_ga(s(0), 0)) → PART_IN_GAAA(s(0))
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
We have to consider all (P,Q,R)-chains.
(215) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
U7_GAAA(
X,
le_out_ga(
X)) →
PART_IN_GAAA(
X) we obtained the following new rules [LPAR04]:
U7_GAAA(s(z0), le_out_ga(s(z0))) → PART_IN_GAAA(s(z0))
U7_GAAA(0, le_out_ga(0)) → PART_IN_GAAA(0)
(216) Obligation:
Q DP problem:
The TRS P consists of the following rules:
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(x0, gt_in_ga(x0)))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(s(0), 0))
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(x0, le_in_ga(x0)))
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga(0))
U5_GAAA(s(z0), gt_out_ga(s(z0), x1)) → PART_IN_GAAA(s(z0))
U5_GAAA(s(0), gt_out_ga(s(0), 0)) → PART_IN_GAAA(s(0))
U7_GAAA(s(z0), le_out_ga(s(z0))) → PART_IN_GAAA(s(z0))
U7_GAAA(0, le_out_ga(0)) → PART_IN_GAAA(0)
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
We have to consider all (P,Q,R)-chains.
(217) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs.
(218) Complex Obligation (AND)
(219) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U7_GAAA(0, le_out_ga(0)) → PART_IN_GAAA(0)
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga(0))
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
We have to consider all (P,Q,R)-chains.
(220) UsableRulesProof (EQUIVALENT transformation)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
(221) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U7_GAAA(0, le_out_ga(0)) → PART_IN_GAAA(0)
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga(0))
R is empty.
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
We have to consider all (P,Q,R)-chains.
(222) QReductionProof (EQUIVALENT transformation)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
(223) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U7_GAAA(0, le_out_ga(0)) → PART_IN_GAAA(0)
PART_IN_GAAA(0) → U7_GAAA(0, le_out_ga(0))
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(224) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:
s =
PART_IN_GAAA(
0) evaluates to t =
PART_IN_GAAA(
0)
Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Matcher: [ ]
- Semiunifier: [ ]
Rewriting sequencePART_IN_GAAA(0) →
U7_GAAA(
0,
le_out_ga(
0))
with rule
PART_IN_GAAA(
0) →
U7_GAAA(
0,
le_out_ga(
0)) at position [] and matcher [ ]
U7_GAAA(0, le_out_ga(0)) →
PART_IN_GAAA(
0)
with rule
U7_GAAA(
0,
le_out_ga(
0)) →
PART_IN_GAAA(
0)
Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence
All these steps are and every following step will be a correct step w.r.t to Q.
(225) FALSE
(226) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U5_GAAA(s(z0), gt_out_ga(s(z0), x1)) → PART_IN_GAAA(s(z0))
PART_IN_GAAA(s(x0)) → U5_GAAA(s(x0), U10_ga(x0, gt_in_ga(x0)))
U5_GAAA(s(0), gt_out_ga(s(0), 0)) → PART_IN_GAAA(s(0))
PART_IN_GAAA(s(0)) → U5_GAAA(s(0), gt_out_ga(s(0), 0))
PART_IN_GAAA(s(x0)) → U7_GAAA(s(x0), U11_ga(x0, le_in_ga(x0)))
U7_GAAA(s(z0), le_out_ga(s(z0))) → PART_IN_GAAA(s(z0))
The TRS R consists of the following rules:
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
The set Q consists of the following terms:
gt_in_ga(x0)
le_in_ga(x0)
U10_ga(x0, x1)
U11_ga(x0, x1)
We have to consider all (P,Q,R)-chains.
(227) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:
s =
PART_IN_GAAA(
s(
0)) evaluates to t =
PART_IN_GAAA(
s(
0))
Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Semiunifier: [ ]
- Matcher: [ ]
Rewriting sequencePART_IN_GAAA(s(0)) →
U5_GAAA(
s(
0),
gt_out_ga(
s(
0),
0))
with rule
PART_IN_GAAA(
s(
0)) →
U5_GAAA(
s(
0),
gt_out_ga(
s(
0),
0)) at position [] and matcher [ ]
U5_GAAA(s(0), gt_out_ga(s(0), 0)) →
PART_IN_GAAA(
s(
0))
with rule
U5_GAAA(
s(
z0),
gt_out_ga(
s(
z0),
x1)) →
PART_IN_GAAA(
s(
z0))
Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence
All these steps are and every following step will be a correct step w.r.t to Q.
(228) FALSE
(229) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
GT_IN_AA(
x1,
x2) =
GT_IN_AA
We have to consider all (P,R,Pi)-chains
(230) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(231) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
R is empty.
The argument filtering Pi contains the following mapping:
s(
x1) =
s(
x1)
GT_IN_AA(
x1,
x2) =
GT_IN_AA
We have to consider all (P,R,Pi)-chains
(232) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(233) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT_IN_AA → GT_IN_AA
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
(234) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.
s =
GT_IN_AA evaluates to t =
GT_IN_AAThus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Matcher: [ ]
- Semiunifier: [ ]
Rewriting sequenceThe DP semiunifies directly so there is only one rewrite step from GT_IN_AA to GT_IN_AA.
(235) FALSE
(236) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
QS_IN_AA(.(X, Xs), Ys) → U1_AA(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
The TRS R consists of the following rules:
qs_in_ag(.(X, Xs), Ys) → U1_ag(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
U1_ag(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_ag(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
qs_in_ga([], []) → qs_out_ga([], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U2_ag(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ag(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa(.(X, Xs), Ys) → U1_aa(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_aa(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_aa(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_aa(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_aa(X, Xs, Ys, Ls, qs_in_aa(Bigs, Bs))
qs_in_aa([], []) → qs_out_aa([], [])
U3_aa(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_aa(X, Xs, Ys, app_in_gaa(Ls, .(X, Bs), Ys))
app_in_gaa(.(X, Xs), Ys, .(X, Zs)) → U9_gaa(X, Xs, Ys, Zs, app_in_gaa(Xs, Ys, Zs))
app_in_gaa([], Ys, Ys) → app_out_gaa([], Ys, Ys)
U9_gaa(X, Xs, Ys, Zs, app_out_gaa(Xs, Ys, Zs)) → app_out_gaa(.(X, Xs), Ys, .(X, Zs))
U4_aa(X, Xs, Ys, app_out_gaa(Ls, .(X, Bs), Ys)) → qs_out_aa(.(X, Xs), Ys)
U3_ag(X, Xs, Ys, Ls, qs_out_aa(Bigs, Bs)) → U4_ag(X, Xs, Ys, app_in_gag(Ls, .(X, Bs), Ys))
app_in_gag(.(X, Xs), Ys, .(X, Zs)) → U9_gag(X, Xs, Ys, Zs, app_in_gag(Xs, Ys, Zs))
app_in_gag([], Ys, Ys) → app_out_gag([], Ys, Ys)
U9_gag(X, Xs, Ys, Zs, app_out_gag(Xs, Ys, Zs)) → app_out_gag(.(X, Xs), Ys, .(X, Zs))
U4_ag(X, Xs, Ys, app_out_gag(Ls, .(X, Bs), Ys)) → qs_out_ag(.(X, Xs), Ys)
qs_in_ag([], []) → qs_out_ag([], [])
The argument filtering Pi contains the following mapping:
qs_in_ag(
x1,
x2) =
qs_in_ag(
x2)
U1_ag(
x1,
x2,
x3,
x4) =
U1_ag(
x3,
x4)
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
U2_ag(
x1,
x2,
x3,
x4,
x5) =
U2_ag(
x3,
x5)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
U3_ag(
x1,
x2,
x3,
x4,
x5) =
U3_ag(
x3,
x4,
x5)
qs_in_aa(
x1,
x2) =
qs_in_aa
U1_aa(
x1,
x2,
x3,
x4) =
U1_aa(
x4)
U2_aa(
x1,
x2,
x3,
x4,
x5) =
U2_aa(
x5)
U3_aa(
x1,
x2,
x3,
x4,
x5) =
U3_aa(
x4,
x5)
qs_out_aa(
x1,
x2) =
qs_out_aa
U4_aa(
x1,
x2,
x3,
x4) =
U4_aa(
x4)
app_in_gaa(
x1,
x2,
x3) =
app_in_gaa(
x1)
U9_gaa(
x1,
x2,
x3,
x4,
x5) =
U9_gaa(
x1,
x2,
x5)
app_out_gaa(
x1,
x2,
x3) =
app_out_gaa(
x1)
U4_ag(
x1,
x2,
x3,
x4) =
U4_ag(
x3,
x4)
app_in_gag(
x1,
x2,
x3) =
app_in_gag(
x1,
x3)
U9_gag(
x1,
x2,
x3,
x4,
x5) =
U9_gag(
x1,
x2,
x4,
x5)
app_out_gag(
x1,
x2,
x3) =
app_out_gag(
x1,
x2,
x3)
qs_out_ag(
x1,
x2) =
qs_out_ag(
x2)
QS_IN_AA(
x1,
x2) =
QS_IN_AA
U1_AA(
x1,
x2,
x3,
x4) =
U1_AA(
x4)
U2_AA(
x1,
x2,
x3,
x4,
x5) =
U2_AA(
x5)
We have to consider all (P,R,Pi)-chains
(237) UsableRulesProof (EQUIVALENT transformation)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
(238) Obligation:
Pi DP problem:
The TRS P consists of the following rules:
QS_IN_AA(.(X, Xs), Ys) → U1_AA(X, Xs, Ys, part_in_aaaa(X, Xs, Littles, Bigs))
U1_AA(X, Xs, Ys, part_out_aaaa(X, Xs, Littles, Bigs)) → U2_AA(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
U2_AA(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → QS_IN_AA(Bigs, Bs)
The TRS R consists of the following rules:
part_in_aaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_aaaa(X, Y, Xs, Ls, Bs, gt_in_aa(X, Y))
part_in_aaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_aaaa(X, Y, Xs, Ls, Bs, le_in_aa(X, Y))
part_in_aaaa(X, [], [], []) → part_out_aaaa(X, [], [], [])
qs_in_ga(.(X, Xs), Ys) → U1_ga(X, Xs, Ys, part_in_ggaa(X, Xs, Littles, Bigs))
qs_in_ga([], []) → qs_out_ga([], [])
U5_aaaa(X, Y, Xs, Ls, Bs, gt_out_aa(X, Y)) → U6_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_aaaa(X, Y, Xs, Ls, Bs, le_out_aa(X, Y)) → U8_aaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U1_ga(X, Xs, Ys, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Ys, Bigs, qs_in_ga(Littles, Ls))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U6_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(X)) → le_out_aa(0, s(X))
le_in_aa(0, 0) → le_out_aa(0, 0)
U8_aaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_aaaa(X, .(Y, Xs), Ls, .(Y, Bs))
part_in_ggaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_ggaa(X, Y, Xs, Ls, Bs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_ggaa(X, Y, Xs, Ls, Bs, le_in_gg(X, Y))
part_in_ggaa(X, [], [], []) → part_out_ggaa(X, [], [], [])
U2_ga(X, Xs, Ys, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ys, Ls, qs_in_ga(Bigs, Bs))
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
part_in_gaaa(X, .(Y, Xs), .(Y, Ls), Bs) → U5_gaaa(X, Y, Xs, Ls, Bs, gt_in_ga(X, Y))
part_in_gaaa(X, .(Y, Xs), Ls, .(Y, Bs)) → U7_gaaa(X, Y, Xs, Ls, Bs, le_in_ga(X, Y))
part_in_gaaa(X, [], [], []) → part_out_gaaa(X, [], [], [])
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U5_ggaa(X, Y, Xs, Ls, Bs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U7_ggaa(X, Y, Xs, Ls, Bs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, Ls, Bs, part_in_ggaa(X, Xs, Ls, Bs))
U3_ga(X, Xs, Ys, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, Ys, app_in_gga(Ls, .(X, Bs), Ys))
U5_gaaa(X, Y, Xs, Ls, Bs, gt_out_ga(X, Y)) → U6_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
U7_gaaa(X, Y, Xs, Ls, Bs, le_out_ga(X, Y)) → U8_gaaa(X, Y, Xs, Ls, Bs, part_in_gaaa(X, Xs, Ls, Bs))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U6_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U8_ggaa(X, Y, Xs, Ls, Bs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U4_ga(X, Xs, Ys, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
gt_in_ga(s(X), s(Y)) → U10_ga(X, Y, gt_in_ga(X, Y))
gt_in_ga(s(0), 0) → gt_out_ga(s(0), 0)
U6_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_ga(s(X), s(Y)) → U11_ga(X, Y, le_in_ga(X, Y))
le_in_ga(0, s(X)) → le_out_ga(0, s(X))
le_in_ga(0, 0) → le_out_ga(0, 0)
U8_gaaa(X, Y, Xs, Ls, Bs, part_out_gaaa(X, Xs, Ls, Bs)) → part_out_gaaa(X, .(Y, Xs), Ls, .(Y, Bs))
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
app_in_gga(.(X, Xs), Ys, .(X, Zs)) → U9_gga(X, Xs, Ys, Zs, app_in_gga(Xs, Ys, Zs))
app_in_gga([], Ys, Ys) → app_out_gga([], Ys, Ys)
U10_ga(X, Y, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, Y, le_out_ga(X, Y)) → le_out_ga(s(X), s(Y))
U9_gga(X, Xs, Ys, Zs, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
The argument filtering Pi contains the following mapping:
part_in_aaaa(
x1,
x2,
x3,
x4) =
part_in_aaaa
U5_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_aaaa(
x6)
gt_in_aa(
x1,
x2) =
gt_in_aa
U10_aa(
x1,
x2,
x3) =
U10_aa(
x3)
gt_out_aa(
x1,
x2) =
gt_out_aa(
x1,
x2)
U6_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_aaaa(
x2,
x6)
part_in_gaaa(
x1,
x2,
x3,
x4) =
part_in_gaaa(
x1)
U5_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_gaaa(
x1,
x6)
gt_in_ga(
x1,
x2) =
gt_in_ga(
x1)
s(
x1) =
s(
x1)
U10_ga(
x1,
x2,
x3) =
U10_ga(
x1,
x3)
0 =
0
gt_out_ga(
x1,
x2) =
gt_out_ga(
x1,
x2)
U6_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_gaaa(
x1,
x2,
x6)
U7_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_gaaa(
x1,
x6)
le_in_ga(
x1,
x2) =
le_in_ga(
x1)
U11_ga(
x1,
x2,
x3) =
U11_ga(
x1,
x3)
le_out_ga(
x1,
x2) =
le_out_ga(
x1)
U8_gaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_gaaa(
x1,
x6)
part_out_gaaa(
x1,
x2,
x3,
x4) =
part_out_gaaa(
x1,
x3)
part_out_aaaa(
x1,
x2,
x3,
x4) =
part_out_aaaa(
x3)
U7_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_aaaa(
x6)
le_in_aa(
x1,
x2) =
le_in_aa
U11_aa(
x1,
x2,
x3) =
U11_aa(
x3)
le_out_aa(
x1,
x2) =
le_out_aa(
x1)
U8_aaaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_aaaa(
x6)
qs_in_ga(
x1,
x2) =
qs_in_ga(
x1)
.(
x1,
x2) =
.(
x1,
x2)
U1_ga(
x1,
x2,
x3,
x4) =
U1_ga(
x1,
x2,
x4)
part_in_ggaa(
x1,
x2,
x3,
x4) =
part_in_ggaa(
x1,
x2)
U5_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U5_ggaa(
x1,
x2,
x3,
x6)
gt_in_gg(
x1,
x2) =
gt_in_gg(
x1,
x2)
U10_gg(
x1,
x2,
x3) =
U10_gg(
x1,
x2,
x3)
gt_out_gg(
x1,
x2) =
gt_out_gg(
x1,
x2)
U6_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U6_ggaa(
x1,
x2,
x3,
x6)
U7_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U7_ggaa(
x1,
x2,
x3,
x6)
le_in_gg(
x1,
x2) =
le_in_gg(
x1,
x2)
U11_gg(
x1,
x2,
x3) =
U11_gg(
x1,
x2,
x3)
le_out_gg(
x1,
x2) =
le_out_gg(
x1,
x2)
U8_ggaa(
x1,
x2,
x3,
x4,
x5,
x6) =
U8_ggaa(
x1,
x2,
x3,
x6)
[] =
[]
part_out_ggaa(
x1,
x2,
x3,
x4) =
part_out_ggaa(
x1,
x2,
x3,
x4)
U2_ga(
x1,
x2,
x3,
x4,
x5) =
U2_ga(
x1,
x2,
x4,
x5)
qs_out_ga(
x1,
x2) =
qs_out_ga(
x1,
x2)
U3_ga(
x1,
x2,
x3,
x4,
x5) =
U3_ga(
x1,
x2,
x4,
x5)
U4_ga(
x1,
x2,
x3,
x4) =
U4_ga(
x1,
x2,
x4)
app_in_gga(
x1,
x2,
x3) =
app_in_gga(
x1,
x2)
U9_gga(
x1,
x2,
x3,
x4,
x5) =
U9_gga(
x1,
x2,
x3,
x5)
app_out_gga(
x1,
x2,
x3) =
app_out_gga(
x1,
x2,
x3)
QS_IN_AA(
x1,
x2) =
QS_IN_AA
U1_AA(
x1,
x2,
x3,
x4) =
U1_AA(
x4)
U2_AA(
x1,
x2,
x3,
x4,
x5) =
U2_AA(
x5)
We have to consider all (P,R,Pi)-chains
(239) PiDPToQDPProof (SOUND transformation)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
(240) Obligation:
Q DP problem:
The TRS P consists of the following rules:
QS_IN_AA → U1_AA(part_in_aaaa)
U1_AA(part_out_aaaa(Littles)) → U2_AA(qs_in_ga(Littles))
U2_AA(qs_out_ga(Littles, Ls)) → QS_IN_AA
The TRS R consists of the following rules:
part_in_aaaa → U5_aaaa(gt_in_aa)
part_in_aaaa → U7_aaaa(le_in_aa)
part_in_aaaa → part_out_aaaa([])
qs_in_ga(.(X, Xs)) → U1_ga(X, Xs, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([], [])
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
U1_ga(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Bigs, qs_in_ga(Littles))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U6_aaaa(Y, part_out_gaaa(X, Ls)) → part_out_aaaa(.(Y, Ls))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U8_aaaa(part_out_gaaa(X, Ls)) → part_out_aaaa(Ls)
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa(X, [], [], [])
U2_ga(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ls, qs_in_ga(Bigs))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa(X, [])
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
U5_ggaa(X, Y, Xs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U7_ggaa(X, Y, Xs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U3_ga(X, Xs, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, app_in_gga(Ls, .(X, Bs)))
U5_gaaa(X, gt_out_ga(X, Y)) → U6_gaaa(X, Y, part_in_gaaa(X))
U7_gaaa(X, le_out_ga(X)) → U8_gaaa(X, part_in_gaaa(X))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U6_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U8_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U4_ga(X, Xs, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
U6_gaaa(X, Y, part_out_gaaa(X, Ls)) → part_out_gaaa(X, .(Y, Ls))
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U8_gaaa(X, part_out_gaaa(X, Ls)) → part_out_gaaa(X, Ls)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
app_in_gga(.(X, Xs), Ys) → U9_gga(X, Xs, Ys, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga([], Ys, Ys)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
U9_gga(X, Xs, Ys, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
The set Q consists of the following terms:
part_in_aaaa
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1, x2)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2, x3)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2, x3)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1, x2, x3)
le_in_gg(x0, x1)
U8_ggaa(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
gt_in_ga(x0)
U6_gaaa(x0, x1, x2)
le_in_ga(x0)
U8_gaaa(x0, x1)
U10_gg(x0, x1, x2)
U11_gg(x0, x1, x2)
app_in_gga(x0, x1)
U10_ga(x0, x1)
U11_ga(x0, x1)
U9_gga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(241) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
QS_IN_AA →
U1_AA(
part_in_aaaa) at position [0] we obtained the following new rules [LPAR04]:
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
(242) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_AA(part_out_aaaa(Littles)) → U2_AA(qs_in_ga(Littles))
U2_AA(qs_out_ga(Littles, Ls)) → QS_IN_AA
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
The TRS R consists of the following rules:
part_in_aaaa → U5_aaaa(gt_in_aa)
part_in_aaaa → U7_aaaa(le_in_aa)
part_in_aaaa → part_out_aaaa([])
qs_in_ga(.(X, Xs)) → U1_ga(X, Xs, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([], [])
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
U1_ga(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Bigs, qs_in_ga(Littles))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U6_aaaa(Y, part_out_gaaa(X, Ls)) → part_out_aaaa(.(Y, Ls))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U8_aaaa(part_out_gaaa(X, Ls)) → part_out_aaaa(Ls)
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa(X, [], [], [])
U2_ga(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ls, qs_in_ga(Bigs))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa(X, [])
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
U5_ggaa(X, Y, Xs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U7_ggaa(X, Y, Xs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U3_ga(X, Xs, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, app_in_gga(Ls, .(X, Bs)))
U5_gaaa(X, gt_out_ga(X, Y)) → U6_gaaa(X, Y, part_in_gaaa(X))
U7_gaaa(X, le_out_ga(X)) → U8_gaaa(X, part_in_gaaa(X))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U6_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U8_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U4_ga(X, Xs, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
U6_gaaa(X, Y, part_out_gaaa(X, Ls)) → part_out_gaaa(X, .(Y, Ls))
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U8_gaaa(X, part_out_gaaa(X, Ls)) → part_out_gaaa(X, Ls)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
app_in_gga(.(X, Xs), Ys) → U9_gga(X, Xs, Ys, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga([], Ys, Ys)
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
U9_gga(X, Xs, Ys, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
The set Q consists of the following terms:
part_in_aaaa
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1, x2)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2, x3)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2, x3)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1, x2, x3)
le_in_gg(x0, x1)
U8_ggaa(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
gt_in_ga(x0)
U6_gaaa(x0, x1, x2)
le_in_ga(x0)
U8_gaaa(x0, x1)
U10_gg(x0, x1, x2)
U11_gg(x0, x1, x2)
app_in_gga(x0, x1)
U10_ga(x0, x1)
U11_ga(x0, x1)
U9_gga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(243) UsableRulesProof (EQUIVALENT transformation)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
(244) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_AA(part_out_aaaa(Littles)) → U2_AA(qs_in_ga(Littles))
U2_AA(qs_out_ga(Littles, Ls)) → QS_IN_AA
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
The TRS R consists of the following rules:
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa(X, [])
U8_aaaa(part_out_gaaa(X, Ls)) → part_out_aaaa(Ls)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U7_gaaa(X, le_out_ga(X)) → U8_gaaa(X, part_in_gaaa(X))
U8_gaaa(X, part_out_gaaa(X, Ls)) → part_out_gaaa(X, Ls)
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
U5_gaaa(X, gt_out_ga(X, Y)) → U6_gaaa(X, Y, part_in_gaaa(X))
U6_gaaa(X, Y, part_out_gaaa(X, Ls)) → part_out_gaaa(X, .(Y, Ls))
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U6_aaaa(Y, part_out_gaaa(X, Ls)) → part_out_aaaa(.(Y, Ls))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
qs_in_ga(.(X, Xs)) → U1_ga(X, Xs, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([], [])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa(X, [], [], [])
U1_ga(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Bigs, qs_in_ga(Littles))
U2_ga(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ls, qs_in_ga(Bigs))
U3_ga(X, Xs, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, app_in_gga(Ls, .(X, Bs)))
app_in_gga(.(X, Xs), Ys) → U9_gga(X, Xs, Ys, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga([], Ys, Ys)
U4_ga(X, Xs, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U9_gga(X, Xs, Ys, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U7_ggaa(X, Y, Xs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U8_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U5_ggaa(X, Y, Xs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U6_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
The set Q consists of the following terms:
part_in_aaaa
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1, x2)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2, x3)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2, x3)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1, x2, x3)
le_in_gg(x0, x1)
U8_ggaa(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
gt_in_ga(x0)
U6_gaaa(x0, x1, x2)
le_in_ga(x0)
U8_gaaa(x0, x1)
U10_gg(x0, x1, x2)
U11_gg(x0, x1, x2)
app_in_gga(x0, x1)
U10_ga(x0, x1)
U11_ga(x0, x1)
U9_gga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(245) QReductionProof (EQUIVALENT transformation)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
part_in_aaaa
(246) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U1_AA(part_out_aaaa(Littles)) → U2_AA(qs_in_ga(Littles))
U2_AA(qs_out_ga(Littles, Ls)) → QS_IN_AA
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
The TRS R consists of the following rules:
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa(X, [])
U8_aaaa(part_out_gaaa(X, Ls)) → part_out_aaaa(Ls)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U7_gaaa(X, le_out_ga(X)) → U8_gaaa(X, part_in_gaaa(X))
U8_gaaa(X, part_out_gaaa(X, Ls)) → part_out_gaaa(X, Ls)
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
U5_gaaa(X, gt_out_ga(X, Y)) → U6_gaaa(X, Y, part_in_gaaa(X))
U6_gaaa(X, Y, part_out_gaaa(X, Ls)) → part_out_gaaa(X, .(Y, Ls))
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U6_aaaa(Y, part_out_gaaa(X, Ls)) → part_out_aaaa(.(Y, Ls))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
qs_in_ga(.(X, Xs)) → U1_ga(X, Xs, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([], [])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa(X, [], [], [])
U1_ga(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Bigs, qs_in_ga(Littles))
U2_ga(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ls, qs_in_ga(Bigs))
U3_ga(X, Xs, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, app_in_gga(Ls, .(X, Bs)))
app_in_gga(.(X, Xs), Ys) → U9_gga(X, Xs, Ys, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga([], Ys, Ys)
U4_ga(X, Xs, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U9_gga(X, Xs, Ys, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U7_ggaa(X, Y, Xs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U8_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U5_ggaa(X, Y, Xs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U6_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
The set Q consists of the following terms:
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1, x2)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2, x3)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2, x3)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1, x2, x3)
le_in_gg(x0, x1)
U8_ggaa(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
gt_in_ga(x0)
U6_gaaa(x0, x1, x2)
le_in_ga(x0)
U8_gaaa(x0, x1)
U10_gg(x0, x1, x2)
U11_gg(x0, x1, x2)
app_in_gga(x0, x1)
U10_ga(x0, x1)
U11_ga(x0, x1)
U9_gga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(247) Narrowing (SOUND transformation)
By narrowing [LPAR04] the rule
U1_AA(
part_out_aaaa(
Littles)) →
U2_AA(
qs_in_ga(
Littles)) at position [0] we obtained the following new rules [LPAR04]:
U1_AA(part_out_aaaa(.(x0, x1))) → U2_AA(U1_ga(x0, x1, part_in_ggaa(x0, x1)))
U1_AA(part_out_aaaa([])) → U2_AA(qs_out_ga([], []))
(248) Obligation:
Q DP problem:
The TRS P consists of the following rules:
U2_AA(qs_out_ga(Littles, Ls)) → QS_IN_AA
QS_IN_AA → U1_AA(U5_aaaa(gt_in_aa))
QS_IN_AA → U1_AA(U7_aaaa(le_in_aa))
QS_IN_AA → U1_AA(part_out_aaaa([]))
U1_AA(part_out_aaaa(.(x0, x1))) → U2_AA(U1_ga(x0, x1, part_in_ggaa(x0, x1)))
U1_AA(part_out_aaaa([])) → U2_AA(qs_out_ga([], []))
The TRS R consists of the following rules:
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0)
U7_aaaa(le_out_aa(X)) → U8_aaaa(part_in_gaaa(X))
part_in_gaaa(X) → U5_gaaa(X, gt_in_ga(X))
part_in_gaaa(X) → U7_gaaa(X, le_in_ga(X))
part_in_gaaa(X) → part_out_gaaa(X, [])
U8_aaaa(part_out_gaaa(X, Ls)) → part_out_aaaa(Ls)
le_in_ga(s(X)) → U11_ga(X, le_in_ga(X))
le_in_ga(0) → le_out_ga(0)
U7_gaaa(X, le_out_ga(X)) → U8_gaaa(X, part_in_gaaa(X))
U8_gaaa(X, part_out_gaaa(X, Ls)) → part_out_gaaa(X, Ls)
U11_ga(X, le_out_ga(X)) → le_out_ga(s(X))
gt_in_ga(s(X)) → U10_ga(X, gt_in_ga(X))
gt_in_ga(s(0)) → gt_out_ga(s(0), 0)
U5_gaaa(X, gt_out_ga(X, Y)) → U6_gaaa(X, Y, part_in_gaaa(X))
U6_gaaa(X, Y, part_out_gaaa(X, Ls)) → part_out_gaaa(X, .(Y, Ls))
U10_ga(X, gt_out_ga(X, Y)) → gt_out_ga(s(X), s(Y))
U11_aa(le_out_aa(X)) → le_out_aa(s(X))
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U5_aaaa(gt_out_aa(X, Y)) → U6_aaaa(Y, part_in_gaaa(X))
U6_aaaa(Y, part_out_gaaa(X, Ls)) → part_out_aaaa(.(Y, Ls))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
qs_in_ga(.(X, Xs)) → U1_ga(X, Xs, part_in_ggaa(X, Xs))
qs_in_ga([]) → qs_out_ga([], [])
part_in_ggaa(X, .(Y, Xs)) → U5_ggaa(X, Y, Xs, gt_in_gg(X, Y))
part_in_ggaa(X, .(Y, Xs)) → U7_ggaa(X, Y, Xs, le_in_gg(X, Y))
part_in_ggaa(X, []) → part_out_ggaa(X, [], [], [])
U1_ga(X, Xs, part_out_ggaa(X, Xs, Littles, Bigs)) → U2_ga(X, Xs, Bigs, qs_in_ga(Littles))
U2_ga(X, Xs, Bigs, qs_out_ga(Littles, Ls)) → U3_ga(X, Xs, Ls, qs_in_ga(Bigs))
U3_ga(X, Xs, Ls, qs_out_ga(Bigs, Bs)) → U4_ga(X, Xs, app_in_gga(Ls, .(X, Bs)))
app_in_gga(.(X, Xs), Ys) → U9_gga(X, Xs, Ys, app_in_gga(Xs, Ys))
app_in_gga([], Ys) → app_out_gga([], Ys, Ys)
U4_ga(X, Xs, app_out_gga(Ls, .(X, Bs), Ys)) → qs_out_ga(.(X, Xs), Ys)
U9_gga(X, Xs, Ys, app_out_gga(Xs, Ys, Zs)) → app_out_gga(.(X, Xs), Ys, .(X, Zs))
le_in_gg(s(X), s(Y)) → U11_gg(X, Y, le_in_gg(X, Y))
le_in_gg(0, s(X)) → le_out_gg(0, s(X))
le_in_gg(0, 0) → le_out_gg(0, 0)
U7_ggaa(X, Y, Xs, le_out_gg(X, Y)) → U8_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U8_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), Ls, .(Y, Bs))
U11_gg(X, Y, le_out_gg(X, Y)) → le_out_gg(s(X), s(Y))
gt_in_gg(s(X), s(Y)) → U10_gg(X, Y, gt_in_gg(X, Y))
gt_in_gg(s(0), 0) → gt_out_gg(s(0), 0)
U5_ggaa(X, Y, Xs, gt_out_gg(X, Y)) → U6_ggaa(X, Y, Xs, part_in_ggaa(X, Xs))
U6_ggaa(X, Y, Xs, part_out_ggaa(X, Xs, Ls, Bs)) → part_out_ggaa(X, .(Y, Xs), .(Y, Ls), Bs)
U10_gg(X, Y, gt_out_gg(X, Y)) → gt_out_gg(s(X), s(Y))
The set Q consists of the following terms:
qs_in_ga(x0)
U5_aaaa(x0)
U7_aaaa(x0)
U1_ga(x0, x1, x2)
gt_in_aa
U6_aaaa(x0, x1)
le_in_aa
U8_aaaa(x0)
part_in_ggaa(x0, x1)
U2_ga(x0, x1, x2, x3)
U10_aa(x0)
part_in_gaaa(x0)
U11_aa(x0)
U5_ggaa(x0, x1, x2, x3)
U7_ggaa(x0, x1, x2, x3)
U3_ga(x0, x1, x2, x3)
U5_gaaa(x0, x1)
U7_gaaa(x0, x1)
gt_in_gg(x0, x1)
U6_ggaa(x0, x1, x2, x3)
le_in_gg(x0, x1)
U8_ggaa(x0, x1, x2, x3)
U4_ga(x0, x1, x2)
gt_in_ga(x0)
U6_gaaa(x0, x1, x2)
le_in_ga(x0)
U8_gaaa(x0, x1)
U10_gg(x0, x1, x2)
U11_gg(x0, x1, x2)
app_in_gga(x0, x1)
U10_ga(x0, x1)
U11_ga(x0, x1)
U9_gga(x0, x1, x2, x3)
We have to consider all (P,Q,R)-chains.
(249) NonTerminationProof (EQUIVALENT transformation)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:
s =
QS_IN_AA evaluates to t =
QS_IN_AAThus s starts an infinite chain as s semiunifies with t with the following substitutions:
- Semiunifier: [ ]
- Matcher: [ ]
Rewriting sequenceQS_IN_AA →
U1_AA(
part_out_aaaa(
[]))
with rule
QS_IN_AA →
U1_AA(
part_out_aaaa(
[])) at position [] and matcher [ ]
U1_AA(part_out_aaaa([])) →
U2_AA(
qs_out_ga(
[],
[]))
with rule
U1_AA(
part_out_aaaa(
[])) →
U2_AA(
qs_out_ga(
[],
[])) at position [] and matcher [ ]
U2_AA(qs_out_ga([], [])) →
QS_IN_AAwith rule
U2_AA(
qs_out_ga(
Littles,
Ls)) →
QS_IN_AANow applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence
All these steps are and every following step will be a correct step w.r.t to Q.
(250) FALSE