YES proof of AProVE_04_AAECC-ring.trs # AProVE Commit ID: c69e44bd14796315568835c1ffa2502984884775 jera 20211004 unpublished Termination w.r.t. Q of the given QTRS could be proven: (0) QTRS (1) AAECC Innermost [EQUIVALENT, 5 ms] (2) QTRS (3) DependencyPairsProof [EQUIVALENT, 0 ms] (4) QDP (5) DependencyGraphProof [EQUIVALENT, 0 ms] (6) AND (7) QDP (8) UsableRulesProof [EQUIVALENT, 0 ms] (9) QDP (10) QReductionProof [EQUIVALENT, 0 ms] (11) QDP (12) QDPSizeChangeProof [EQUIVALENT, 0 ms] (13) YES (14) QDP (15) UsableRulesProof [EQUIVALENT, 0 ms] (16) QDP (17) QReductionProof [EQUIVALENT, 0 ms] (18) QDP (19) QDPSizeChangeProof [EQUIVALENT, 0 ms] (20) YES (21) QDP (22) UsableRulesProof [EQUIVALENT, 0 ms] (23) QDP (24) QReductionProof [EQUIVALENT, 0 ms] (25) QDP (26) QDPSizeChangeProof [EQUIVALENT, 0 ms] (27) YES (28) QDP (29) UsableRulesProof [EQUIVALENT, 0 ms] (30) QDP (31) QReductionProof [EQUIVALENT, 0 ms] (32) QDP (33) QDPSizeChangeProof [EQUIVALENT, 0 ms] (34) YES (35) QDP (36) UsableRulesProof [EQUIVALENT, 0 ms] (37) QDP (38) QReductionProof [EQUIVALENT, 0 ms] (39) QDP (40) QDPSizeChangeProof [EQUIVALENT, 0 ms] (41) YES (42) QDP (43) UsableRulesProof [EQUIVALENT, 0 ms] (44) QDP (45) QReductionProof [EQUIVALENT, 0 ms] (46) QDP (47) QDPSizeChangeProof [EQUIVALENT, 0 ms] (48) YES (49) QDP (50) UsableRulesProof [EQUIVALENT, 0 ms] (51) QDP (52) QReductionProof [EQUIVALENT, 0 ms] (53) QDP (54) TransformationProof [EQUIVALENT, 0 ms] (55) QDP (56) TransformationProof [EQUIVALENT, 4 ms] (57) QDP (58) QDPQMonotonicMRRProof [EQUIVALENT, 99 ms] (59) QDP (60) TransformationProof [EQUIVALENT, 0 ms] (61) QDP (62) DependencyGraphProof [EQUIVALENT, 0 ms] (63) QDP (64) TransformationProof [EQUIVALENT, 0 ms] (65) QDP (66) TransformationProof [EQUIVALENT, 0 ms] (67) QDP (68) TransformationProof [EQUIVALENT, 0 ms] (69) QDP (70) DependencyGraphProof [EQUIVALENT, 0 ms] (71) QDP (72) TransformationProof [EQUIVALENT, 0 ms] (73) QDP (74) TransformationProof [EQUIVALENT, 0 ms] (75) QDP (76) TransformationProof [EQUIVALENT, 0 ms] (77) QDP (78) DependencyGraphProof [EQUIVALENT, 0 ms] (79) QDP (80) TransformationProof [EQUIVALENT, 0 ms] (81) QDP (82) TransformationProof [EQUIVALENT, 0 ms] (83) QDP (84) DependencyGraphProof [EQUIVALENT, 0 ms] (85) QDP (86) TransformationProof [EQUIVALENT, 0 ms] (87) QDP (88) DependencyGraphProof [EQUIVALENT, 0 ms] (89) QDP (90) TransformationProof [EQUIVALENT, 0 ms] (91) QDP (92) TransformationProof [EQUIVALENT, 0 ms] (93) QDP (94) TransformationProof [EQUIVALENT, 0 ms] (95) QDP (96) TransformationProof [EQUIVALENT, 0 ms] (97) QDP (98) TransformationProof [EQUIVALENT, 0 ms] (99) QDP (100) DependencyGraphProof [EQUIVALENT, 0 ms] (101) QDP (102) TransformationProof [EQUIVALENT, 0 ms] (103) QDP (104) TransformationProof [EQUIVALENT, 2 ms] (105) QDP (106) TransformationProof [EQUIVALENT, 0 ms] (107) QDP (108) TransformationProof [EQUIVALENT, 0 ms] (109) QDP (110) TransformationProof [EQUIVALENT, 0 ms] (111) QDP (112) TransformationProof [EQUIVALENT, 0 ms] (113) QDP (114) TransformationProof [EQUIVALENT, 0 ms] (115) QDP (116) TransformationProof [EQUIVALENT, 0 ms] (117) QDP (118) TransformationProof [EQUIVALENT, 0 ms] (119) QDP (120) DependencyGraphProof [EQUIVALENT, 0 ms] (121) QDP (122) TransformationProof [EQUIVALENT, 0 ms] (123) QDP (124) TransformationProof [EQUIVALENT, 0 ms] (125) QDP (126) TransformationProof [EQUIVALENT, 0 ms] (127) QDP (128) TransformationProof [EQUIVALENT, 0 ms] (129) QDP (130) UsableRulesProof [EQUIVALENT, 0 ms] (131) QDP (132) QReductionProof [EQUIVALENT, 0 ms] (133) QDP (134) TransformationProof [EQUIVALENT, 0 ms] (135) QDP (136) TransformationProof [EQUIVALENT, 0 ms] (137) QDP (138) UsableRulesProof [EQUIVALENT, 0 ms] (139) QDP (140) QReductionProof [EQUIVALENT, 0 ms] (141) QDP (142) TransformationProof [EQUIVALENT, 0 ms] (143) QDP (144) DependencyGraphProof [EQUIVALENT, 0 ms] (145) QDP (146) TransformationProof [EQUIVALENT, 0 ms] (147) QDP (148) TransformationProof [EQUIVALENT, 0 ms] (149) QDP (150) TransformationProof [EQUIVALENT, 0 ms] (151) QDP (152) TransformationProof [EQUIVALENT, 0 ms] (153) QDP (154) TransformationProof [EQUIVALENT, 0 ms] (155) QDP (156) TransformationProof [EQUIVALENT, 0 ms] (157) QDP (158) QDPSizeChangeProof [EQUIVALENT, 0 ms] (159) YES ---------------------------------------- (0) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) Q is empty. ---------------------------------------- (1) AAECC Innermost (EQUIVALENT) We have applied [NOC,AAECCNOC] to switch to innermost. The TRS R 1 is sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The TRS R 2 is ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The signature Sigma is {ring_6, if_1_7, if_2_7, if_3_7, if_4_7, if_5_7, if_6_7, if_7_7, if_8_7, if_9_7} ---------------------------------------- (2) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) ---------------------------------------- (3) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem. ---------------------------------------- (4) Obligation: Q DP problem: The TRS P consists of the following rules: FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t) SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t) LEQ(s(n), s(m)) -> LEQ(n, m) LENGTH(cons(h, t)) -> LENGTH(t) APP(cons(h, t), x) -> APP(t, x) MAP_F(pid, cons(h, t)) -> APP(f(pid, h), map_f(pid, t)) MAP_F(pid, cons(h, t)) -> MAP_F(pid, t) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) RING(st_1, in_2, st_2, in_3, st_3, m) -> EMPTY(fstsplit(m, st_1)) RING(st_1, in_2, st_2, in_3, st_3, m) -> FSTSPLIT(m, st_1) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> SNDSPLIT(m, st_1) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> FSTSPLIT(m, st_1) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) RING(st_1, in_2, st_2, in_3, st_3, m) -> LEQ(m, length(st_2)) RING(st_1, in_2, st_2, in_3, st_3, m) -> LENGTH(st_2) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> EMPTY(fstsplit(m, st_2)) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> FSTSPLIT(m, st_2) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> SNDSPLIT(m, st_2) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> FSTSPLIT(m, st_2) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> EMPTY(fstsplit(m, app(map_f(two, head(in_2)), st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> FSTSPLIT(m, app(map_f(two, head(in_2)), st_2)) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> APP(map_f(two, head(in_2)), st_2) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> MAP_F(two, head(in_2)) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> HEAD(in_2) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> TAIL(in_2) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> SNDSPLIT(m, app(map_f(two, head(in_2)), st_2)) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> APP(map_f(two, head(in_2)), st_2) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> MAP_F(two, head(in_2)) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> HEAD(in_2) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> FSTSPLIT(m, app(map_f(two, head(in_2)), st_2)) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) RING(st_1, in_2, st_2, in_3, st_3, m) -> EMPTY(map_f(two, head(in_2))) RING(st_1, in_2, st_2, in_3, st_3, m) -> MAP_F(two, head(in_2)) RING(st_1, in_2, st_2, in_3, st_3, m) -> HEAD(in_2) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> TAIL(in_2) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) RING(st_1, in_2, st_2, in_3, st_3, m) -> LEQ(m, length(st_3)) RING(st_1, in_2, st_2, in_3, st_3, m) -> LENGTH(st_3) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> EMPTY(fstsplit(m, st_3)) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> FSTSPLIT(m, st_3) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> SNDSPLIT(m, st_3) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> EMPTY(fstsplit(m, app(map_f(three, head(in_3)), st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> FSTSPLIT(m, app(map_f(three, head(in_3)), st_3)) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> APP(map_f(three, head(in_3)), st_3) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> MAP_F(three, head(in_3)) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> HEAD(in_3) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> TAIL(in_3) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> SNDSPLIT(m, app(map_f(three, head(in_3)), st_3)) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> APP(map_f(three, head(in_3)), st_3) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> MAP_F(three, head(in_3)) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> HEAD(in_3) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) RING(st_1, in_2, st_2, in_3, st_3, m) -> EMPTY(map_f(three, head(in_3))) RING(st_1, in_2, st_2, in_3, st_3, m) -> MAP_F(three, head(in_3)) RING(st_1, in_2, st_2, in_3, st_3, m) -> HEAD(in_3) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> TAIL(in_3) The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (5) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 7 SCCs with 45 less nodes. ---------------------------------------- (6) Complex Obligation (AND) ---------------------------------------- (7) Obligation: Q DP problem: The TRS P consists of the following rules: APP(cons(h, t), x) -> APP(t, x) The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (8) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (9) Obligation: Q DP problem: The TRS P consists of the following rules: APP(cons(h, t), x) -> APP(t, x) R is empty. The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (10) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) ---------------------------------------- (11) Obligation: Q DP problem: The TRS P consists of the following rules: APP(cons(h, t), x) -> APP(t, x) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (12) QDPSizeChangeProof (EQUIVALENT) 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(cons(h, t), x) -> APP(t, x) The graph contains the following edges 1 > 1, 2 >= 2 ---------------------------------------- (13) YES ---------------------------------------- (14) Obligation: Q DP problem: The TRS P consists of the following rules: MAP_F(pid, cons(h, t)) -> MAP_F(pid, t) The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (15) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (16) Obligation: Q DP problem: The TRS P consists of the following rules: MAP_F(pid, cons(h, t)) -> MAP_F(pid, t) R is empty. The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (17) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) ---------------------------------------- (18) Obligation: Q DP problem: The TRS P consists of the following rules: MAP_F(pid, cons(h, t)) -> MAP_F(pid, t) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (19) QDPSizeChangeProof (EQUIVALENT) 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: *MAP_F(pid, cons(h, t)) -> MAP_F(pid, t) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (20) YES ---------------------------------------- (21) Obligation: Q DP problem: The TRS P consists of the following rules: LENGTH(cons(h, t)) -> LENGTH(t) The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (22) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (23) Obligation: Q DP problem: The TRS P consists of the following rules: LENGTH(cons(h, t)) -> LENGTH(t) R is empty. The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (24) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) ---------------------------------------- (25) Obligation: Q DP problem: The TRS P consists of the following rules: LENGTH(cons(h, t)) -> LENGTH(t) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (26) QDPSizeChangeProof (EQUIVALENT) 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: *LENGTH(cons(h, t)) -> LENGTH(t) The graph contains the following edges 1 > 1 ---------------------------------------- (27) YES ---------------------------------------- (28) Obligation: Q DP problem: The TRS P consists of the following rules: LEQ(s(n), s(m)) -> LEQ(n, m) The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (29) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (30) Obligation: Q DP problem: The TRS P consists of the following rules: LEQ(s(n), s(m)) -> LEQ(n, m) R is empty. The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (31) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) ---------------------------------------- (32) Obligation: Q DP problem: The TRS P consists of the following rules: LEQ(s(n), s(m)) -> LEQ(n, m) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (33) QDPSizeChangeProof (EQUIVALENT) 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: *LEQ(s(n), s(m)) -> LEQ(n, m) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (34) YES ---------------------------------------- (35) Obligation: Q DP problem: The TRS P consists of the following rules: SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t) The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (36) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (37) Obligation: Q DP problem: The TRS P consists of the following rules: SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t) R is empty. The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (38) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) ---------------------------------------- (39) Obligation: Q DP problem: The TRS P consists of the following rules: SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (40) QDPSizeChangeProof (EQUIVALENT) 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: *SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (41) YES ---------------------------------------- (42) Obligation: Q DP problem: The TRS P consists of the following rules: FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t) The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (43) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (44) Obligation: Q DP problem: The TRS P consists of the following rules: FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t) R is empty. The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (45) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) ---------------------------------------- (46) Obligation: Q DP problem: The TRS P consists of the following rules: FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (47) QDPSizeChangeProof (EQUIVALENT) 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: *FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (48) YES ---------------------------------------- (49) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) The TRS R consists of the following rules: fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) empty(nil) -> true empty(cons(h, t)) -> false leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) length(nil) -> 0 length(cons(h, t)) -> s(length(t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) head(cons(h, t)) -> h tail(cons(h, t)) -> t ring(st_1, in_2, st_2, in_3, st_3, m) -> if_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) if_1(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) if_2(st_1, in_2, st_2, in_3, st_3, m, true) -> if_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) if_3(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) if_2(st_1, in_2, st_2, in_3, st_3, m, false) -> if_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) if_4(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) if_5(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, tail(in_2), st_2, in_3, st_3, m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) if_6(st_1, in_2, st_2, in_3, st_3, m, true) -> if_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) if_7(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) if_6(st_1, in_2, st_2, in_3, st_3, m, false) -> if_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) if_8(st_1, in_2, st_2, in_3, st_3, m, false) -> ring(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) ring(st_1, in_2, st_2, in_3, st_3, m) -> if_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) if_9(st_1, in_2, st_2, in_3, st_3, m, true) -> ring(st_1, in_2, st_2, tail(in_3), st_3, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (50) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (51) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (52) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. ring(x0, x1, x2, x3, x4, x5) if_1(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, true) if_3(x0, x1, x2, x3, x4, x5, false) if_2(x0, x1, x2, x3, x4, x5, false) if_4(x0, x1, x2, x3, x4, x5, false) if_5(x0, x1, x2, x3, x4, x5, true) if_6(x0, x1, x2, x3, x4, x5, true) if_7(x0, x1, x2, x3, x4, x5, false) if_6(x0, x1, x2, x3, x4, x5, false) if_8(x0, x1, x2, x3, x4, x5, false) if_9(x0, x1, x2, x3, x4, x5, true) ---------------------------------------- (53) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (54) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_5(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(two, head(in_2)))) at position [6] we obtained the following new rules [LPAR04]: (RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))),RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0)))) ---------------------------------------- (55) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (56) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_9(st_1, in_2, st_2, in_3, st_3, m, empty(map_f(three, head(in_3)))) at position [6] we obtained the following new rules [LPAR04]: (RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))),RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0)))) ---------------------------------------- (57) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (58) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented rules of the TRS R: sndsplit(s(n), cons(h, t)) -> sndsplit(n, t) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(IF_1(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 POL(IF_2(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 + x_7 POL(IF_3(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 POL(IF_4(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 POL(IF_5(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 POL(IF_6(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 + x_7 POL(IF_7(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 POL(IF_8(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 POL(IF_9(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 POL(RING(x_1, x_2, x_3, x_4, x_5, x_6)) = 2 + 2*x_1 + x_3 + 2*x_5 + x_6 POL(app(x_1, x_2)) = 2*x_1 + x_2 POL(cons(x_1, x_2)) = 1 + 2*x_1 + x_2 POL(empty(x_1)) = 1 POL(f(x_1, x_2)) = 0 POL(false) = 0 POL(fstsplit(x_1, x_2)) = 1 + 2*x_2 POL(head(x_1)) = x_1 POL(length(x_1)) = 0 POL(leq(x_1, x_2)) = x_2 POL(map_f(x_1, x_2)) = 0 POL(nil) = 0 POL(s(x_1)) = x_1 POL(sndsplit(x_1, x_2)) = x_2 POL(tail(x_1)) = x_1 POL(three) = 0 POL(true) = 0 POL(two) = 2 ---------------------------------------- (59) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (60) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_1(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_1))) at position [6] we obtained the following new rules [LPAR04]: (RING(x0, y1, y2, y3, y4, 0) -> IF_1(x0, y1, y2, y3, y4, 0, empty(nil)),RING(x0, y1, y2, y3, y4, 0) -> IF_1(x0, y1, y2, y3, y4, 0, empty(nil))) (RING(nil, y1, y2, y3, y4, s(x0)) -> IF_1(nil, y1, y2, y3, y4, s(x0), empty(nil)),RING(nil, y1, y2, y3, y4, s(x0)) -> IF_1(nil, y1, y2, y3, y4, s(x0), empty(nil))) (RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2)))),RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2))))) ---------------------------------------- (61) Obligation: Q DP problem: The TRS P consists of the following rules: IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) RING(x0, y1, y2, y3, y4, 0) -> IF_1(x0, y1, y2, y3, y4, 0, empty(nil)) RING(nil, y1, y2, y3, y4, s(x0)) -> IF_1(nil, y1, y2, y3, y4, s(x0), empty(nil)) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2)))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (62) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (63) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2)))) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (64) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2)))) at position [6] we obtained the following new rules [LPAR04]: (RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false),RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false)) ---------------------------------------- (65) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (66) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_2(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_2))) at position [6] we obtained the following new rules [LPAR04]: (RING(y0, y1, y2, y3, y4, 0) -> IF_2(y0, y1, y2, y3, y4, 0, true),RING(y0, y1, y2, y3, y4, 0) -> IF_2(y0, y1, y2, y3, y4, 0, true)) (RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)),RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0))) (RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))),RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1))))) ---------------------------------------- (67) Obligation: Q DP problem: The TRS P consists of the following rules: IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) RING(y0, y1, y2, y3, y4, 0) -> IF_2(y0, y1, y2, y3, y4, 0, true) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (68) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule IF_2(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_3(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_2))) at position [6] we obtained the following new rules [LPAR04]: (IF_2(y0, y1, x0, y3, y4, 0, true) -> IF_3(y0, y1, x0, y3, y4, 0, empty(nil)),IF_2(y0, y1, x0, y3, y4, 0, true) -> IF_3(y0, y1, x0, y3, y4, 0, empty(nil))) (IF_2(y0, y1, nil, y3, y4, s(x0), true) -> IF_3(y0, y1, nil, y3, y4, s(x0), empty(nil)),IF_2(y0, y1, nil, y3, y4, s(x0), true) -> IF_3(y0, y1, nil, y3, y4, s(x0), empty(nil))) (IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2)))),IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2))))) ---------------------------------------- (69) Obligation: Q DP problem: The TRS P consists of the following rules: IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) RING(y0, y1, y2, y3, y4, 0) -> IF_2(y0, y1, y2, y3, y4, 0, true) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, x0, y3, y4, 0, true) -> IF_3(y0, y1, x0, y3, y4, 0, empty(nil)) IF_2(y0, y1, nil, y3, y4, s(x0), true) -> IF_3(y0, y1, nil, y3, y4, s(x0), empty(nil)) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2)))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (70) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes. ---------------------------------------- (71) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2)))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (72) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), empty(cons(x1, fstsplit(x0, x2)))) at position [6] we obtained the following new rules [LPAR04]: (IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false),IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false)) ---------------------------------------- (73) Obligation: Q DP problem: The TRS P consists of the following rules: RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (74) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule RING(st_1, in_2, st_2, in_3, st_3, m) -> IF_6(st_1, in_2, st_2, in_3, st_3, m, leq(m, length(st_3))) at position [6] we obtained the following new rules [LPAR04]: (RING(y0, y1, y2, y3, y4, 0) -> IF_6(y0, y1, y2, y3, y4, 0, true),RING(y0, y1, y2, y3, y4, 0) -> IF_6(y0, y1, y2, y3, y4, 0, true)) (RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)),RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0))) (RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))),RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1))))) ---------------------------------------- (75) Obligation: Q DP problem: The TRS P consists of the following rules: IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) RING(y0, y1, y2, y3, y4, 0) -> IF_6(y0, y1, y2, y3, y4, 0, true) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (76) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule IF_6(st_1, in_2, st_2, in_3, st_3, m, true) -> IF_7(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, st_3))) at position [6] we obtained the following new rules [LPAR04]: (IF_6(y0, y1, y2, y3, x0, 0, true) -> IF_7(y0, y1, y2, y3, x0, 0, empty(nil)),IF_6(y0, y1, y2, y3, x0, 0, true) -> IF_7(y0, y1, y2, y3, x0, 0, empty(nil))) (IF_6(y0, y1, y2, y3, nil, s(x0), true) -> IF_7(y0, y1, y2, y3, nil, s(x0), empty(nil)),IF_6(y0, y1, y2, y3, nil, s(x0), true) -> IF_7(y0, y1, y2, y3, nil, s(x0), empty(nil))) (IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), empty(cons(x1, fstsplit(x0, x2)))),IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), empty(cons(x1, fstsplit(x0, x2))))) ---------------------------------------- (77) Obligation: Q DP problem: The TRS P consists of the following rules: IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) RING(y0, y1, y2, y3, y4, 0) -> IF_6(y0, y1, y2, y3, y4, 0, true) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, x0, 0, true) -> IF_7(y0, y1, y2, y3, x0, 0, empty(nil)) IF_6(y0, y1, y2, y3, nil, s(x0), true) -> IF_7(y0, y1, y2, y3, nil, s(x0), empty(nil)) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), empty(cons(x1, fstsplit(x0, x2)))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (78) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes. ---------------------------------------- (79) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), empty(cons(x1, fstsplit(x0, x2)))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (80) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), empty(cons(x1, fstsplit(x0, x2)))) at position [6] we obtained the following new rules [LPAR04]: (IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false),IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false)) ---------------------------------------- (81) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (82) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule IF_2(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_4(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(two, head(in_2)), st_2)))) at position [6] we obtained the following new rules [LPAR04]: (IF_2(y0, y1, y2, y3, y4, 0, false) -> IF_4(y0, y1, y2, y3, y4, 0, empty(nil)),IF_2(y0, y1, y2, y3, y4, 0, false) -> IF_4(y0, y1, y2, y3, y4, 0, empty(nil))) (IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))),IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2))))) ---------------------------------------- (83) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_2(y0, y1, y2, y3, y4, 0, false) -> IF_4(y0, y1, y2, y3, y4, 0, empty(nil)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (84) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (85) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (86) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule IF_6(st_1, in_2, st_2, in_3, st_3, m, false) -> IF_8(st_1, in_2, st_2, in_3, st_3, m, empty(fstsplit(m, app(map_f(three, head(in_3)), st_3)))) at position [6] we obtained the following new rules [LPAR04]: (IF_6(y0, y1, y2, y3, y4, 0, false) -> IF_8(y0, y1, y2, y3, y4, 0, empty(nil)),IF_6(y0, y1, y2, y3, y4, 0, false) -> IF_8(y0, y1, y2, y3, y4, 0, empty(nil))) (IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))),IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4))))) ---------------------------------------- (87) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(y0, y1, y2, y3, y4, 0, false) -> IF_8(y0, y1, y2, y3, y4, 0, empty(nil)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (88) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (89) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (90) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_5(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, tail(in_2), st_2, in_3, st_3, m) we obtained the following new rules [LPAR04]: (IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, tail(cons(z1, z2)), z3, z4, z5, z6),IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, tail(cons(z1, z2)), z3, z4, z5, z6)) ---------------------------------------- (91) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, tail(cons(z1, z2)), z3, z4, z5, z6) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (92) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, tail(cons(z1, z2)), z3, z4, z5, z6) at position [1] we obtained the following new rules [LPAR04]: (IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6),IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6)) ---------------------------------------- (93) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (94) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_9(st_1, in_2, st_2, in_3, st_3, m, true) -> RING(st_1, in_2, st_2, tail(in_3), st_3, m) we obtained the following new rules [LPAR04]: (IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, tail(cons(z3, z4)), z5, z6),IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, tail(cons(z3, z4)), z5, z6)) ---------------------------------------- (95) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, tail(cons(z3, z4)), z5, z6) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (96) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, tail(cons(z3, z4)), z5, z6) at position [3] we obtained the following new rules [LPAR04]: (IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6),IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6)) ---------------------------------------- (97) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (98) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_1(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(sndsplit(m, st_1), cons(fstsplit(m, st_1), in_2), st_2, in_3, st_3, m) we obtained the following new rules [LPAR04]: (IF_1(cons(z0, z1), z2, z3, z4, z5, s(z6), false) -> RING(sndsplit(s(z6), cons(z0, z1)), cons(fstsplit(s(z6), cons(z0, z1)), z2), z3, z4, z5, s(z6)),IF_1(cons(z0, z1), z2, z3, z4, z5, s(z6), false) -> RING(sndsplit(s(z6), cons(z0, z1)), cons(fstsplit(s(z6), cons(z0, z1)), z2), z3, z4, z5, s(z6))) ---------------------------------------- (99) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) RING(cons(x1, x2), y1, y2, y3, y4, s(x0)) -> IF_1(cons(x1, x2), y1, y2, y3, y4, s(x0), false) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) IF_1(cons(z0, z1), z2, z3, z4, z5, s(z6), false) -> RING(sndsplit(s(z6), cons(z0, z1)), cons(fstsplit(s(z6), cons(z0, z1)), z2), z3, z4, z5, s(z6)) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (100) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (101) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (102) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_2(y0, cons(x0, x1), y2, y3, y4, y5, false) -> IF_4(y0, cons(x0, x1), y2, y3, y4, y5, empty(fstsplit(y5, app(map_f(two, x0), y2)))) we obtained the following new rules [LPAR04]: (IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))),IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil))))) (IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))),IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3)))))) ---------------------------------------- (103) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (104) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_4(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, tail(in_2), sndsplit(m, app(map_f(two, head(in_2)), st_2)), cons(fstsplit(m, app(map_f(two, head(in_2)), st_2)), in_3), st_3, m) we obtained the following new rules [LPAR04]: (IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5),IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5)) (IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7),IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7)) ---------------------------------------- (105) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (106) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5) at position [1] we obtained the following new rules [LPAR04]: (IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5),IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5)) ---------------------------------------- (107) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (108) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, tail(cons(z1, z2)), sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) at position [1] we obtained the following new rules [LPAR04]: (IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7),IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7)) ---------------------------------------- (109) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (110) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5) at position [2,1,0,1] we obtained the following new rules [LPAR04]: (IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5),IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5)) ---------------------------------------- (111) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (112) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) at position [2,1,0,1] we obtained the following new rules [LPAR04]: (IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7),IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7)) ---------------------------------------- (113) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (114) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, head(cons(z1, z2))), nil)), z3), z4, z5) at position [3,0,1,0,1] we obtained the following new rules [LPAR04]: (IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5),IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5)) ---------------------------------------- (115) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (116) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, head(cons(z1, z2))), cons(z3, z4))), z5), z6, z7) at position [3,0,1,0,1] we obtained the following new rules [LPAR04]: (IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7),IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7)) ---------------------------------------- (117) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (118) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_3(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, sndsplit(m, st_2), cons(fstsplit(m, st_2), in_3), st_3, m) we obtained the following new rules [LPAR04]: (IF_3(z0, z1, cons(z2, z3), z4, z5, s(z6), false) -> RING(z0, z1, sndsplit(s(z6), cons(z2, z3)), cons(fstsplit(s(z6), cons(z2, z3)), z4), z5, s(z6)),IF_3(z0, z1, cons(z2, z3), z4, z5, s(z6), false) -> RING(z0, z1, sndsplit(s(z6), cons(z2, z3)), cons(fstsplit(s(z6), cons(z2, z3)), z4), z5, s(z6))) ---------------------------------------- (119) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(y0, y1, cons(x1, x2), y3, y4, s(x0), true) -> IF_3(y0, y1, cons(x1, x2), y3, y4, s(x0), false) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) IF_3(z0, z1, cons(z2, z3), z4, z5, s(z6), false) -> RING(z0, z1, sndsplit(s(z6), cons(z2, z3)), cons(fstsplit(s(z6), cons(z2, z3)), z4), z5, s(z6)) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (120) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (121) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (122) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_6(y0, y1, y2, cons(x0, x1), y4, y5, false) -> IF_8(y0, y1, y2, cons(x0, x1), y4, y5, empty(fstsplit(y5, app(map_f(three, x0), y4)))) we obtained the following new rules [LPAR04]: (IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))),IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil))))) (IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))),IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5)))))) ---------------------------------------- (123) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (124) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_8(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, tail(in_3), sndsplit(m, app(map_f(three, head(in_3)), st_3)), m) we obtained the following new rules [LPAR04]: (IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5),IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5)) (IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7),IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7)) ---------------------------------------- (125) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (126) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5) at position [3] we obtained the following new rules [LPAR04]: (IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5),IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5)) ---------------------------------------- (127) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (128) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, tail(cons(z3, z4)), sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7) at position [3] we obtained the following new rules [LPAR04]: (IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7),IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7)) ---------------------------------------- (129) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7) The TRS R consists of the following rules: tail(cons(h, t)) -> t head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), 0) -> false leq(s(n), s(m)) -> leq(n, m) The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (130) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (131) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7) The TRS R consists of the following rules: head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) tail(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (132) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. tail(cons(x0, x1)) ---------------------------------------- (133) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7) The TRS R consists of the following rules: head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (134) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, head(cons(z3, z4))), nil)), z5) at position [4,1,0,1] we obtained the following new rules [LPAR04]: (IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5),IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5)) ---------------------------------------- (135) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) The TRS R consists of the following rules: head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (136) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, head(cons(z3, z4))), cons(z5, z6))), z7) at position [4,1,0,1] we obtained the following new rules [LPAR04]: (IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7),IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7)) ---------------------------------------- (137) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) The TRS R consists of the following rules: head(cons(h, t)) -> h map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (138) UsableRulesProof (EQUIVALENT) 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. ---------------------------------------- (139) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) head(cons(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (140) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. head(cons(x0, x1)) ---------------------------------------- (141) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (142) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_7(st_1, in_2, st_2, in_3, st_3, m, false) -> RING(st_1, in_2, st_2, in_3, sndsplit(m, st_3), m) we obtained the following new rules [LPAR04]: (IF_7(z0, z1, z2, z3, cons(z4, z5), s(z6), false) -> RING(z0, z1, z2, z3, sndsplit(s(z6), cons(z4, z5)), s(z6)),IF_7(z0, z1, z2, z3, cons(z4, z5), s(z6), false) -> RING(z0, z1, z2, z3, sndsplit(s(z6), cons(z4, z5)), s(z6))) ---------------------------------------- (143) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(y0, y1, y2, y3, cons(x1, x2), s(x0), true) -> IF_7(y0, y1, y2, y3, cons(x1, x2), s(x0), false) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) IF_7(z0, z1, z2, z3, cons(z4, z5), s(z6), false) -> RING(z0, z1, z2, z3, sndsplit(s(z6), cons(z4, z5)), s(z6)) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (144) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (145) Obligation: Q DP problem: The TRS P consists of the following rules: IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (146) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule IF_5(z0, cons(z1, z2), z3, z4, z5, z6, true) -> RING(z0, z2, z3, z4, z5, z6) we obtained the following new rules [LPAR04]: (IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6),IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6)) (IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6),IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6)) (IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6),IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6)) (IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6),IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6)) (IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6),IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6)) (IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6),IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6)) ---------------------------------------- (147) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6) IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6) IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6) IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6) IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6) IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (148) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule IF_9(z0, z1, z2, cons(z3, z4), z5, z6, true) -> RING(z0, z1, z2, z4, z5, z6) we obtained the following new rules [LPAR04]: (IF_9(x0, cons(y_1, y_2), x2, cons(x3, x4), x5, x6, true) -> RING(x0, cons(y_1, y_2), x2, x4, x5, x6),IF_9(x0, cons(y_1, y_2), x2, cons(x3, x4), x5, x6, true) -> RING(x0, cons(y_1, y_2), x2, x4, x5, x6)) (IF_9(x0, x1, x2, cons(x3, cons(y_3, y_4)), x5, x6, true) -> RING(x0, x1, x2, cons(y_3, y_4), x5, x6),IF_9(x0, x1, x2, cons(x3, cons(y_3, y_4)), x5, x6, true) -> RING(x0, x1, x2, cons(y_3, y_4), x5, x6)) (IF_9(x0, x1, nil, cons(x3, x4), x5, x6, true) -> RING(x0, x1, nil, x4, x5, x6),IF_9(x0, x1, nil, cons(x3, x4), x5, x6, true) -> RING(x0, x1, nil, x4, x5, x6)) (IF_9(x0, x1, cons(y_2, y_3), cons(x3, x4), x5, x6, true) -> RING(x0, x1, cons(y_2, y_3), x4, x5, x6),IF_9(x0, x1, cons(y_2, y_3), cons(x3, x4), x5, x6, true) -> RING(x0, x1, cons(y_2, y_3), x4, x5, x6)) (IF_9(x0, x1, x2, cons(x3, x4), nil, x6, true) -> RING(x0, x1, x2, x4, nil, x6),IF_9(x0, x1, x2, cons(x3, x4), nil, x6, true) -> RING(x0, x1, x2, x4, nil, x6)) (IF_9(x0, x1, x2, cons(x3, x4), cons(y_4, y_5), x6, true) -> RING(x0, x1, x2, x4, cons(y_4, y_5), x6),IF_9(x0, x1, x2, cons(x3, x4), cons(y_4, y_5), x6, true) -> RING(x0, x1, x2, x4, cons(y_4, y_5), x6)) ---------------------------------------- (149) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6) IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6) IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6) IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6) IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6) IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6) IF_9(x0, cons(y_1, y_2), x2, cons(x3, x4), x5, x6, true) -> RING(x0, cons(y_1, y_2), x2, x4, x5, x6) IF_9(x0, x1, x2, cons(x3, cons(y_3, y_4)), x5, x6, true) -> RING(x0, x1, x2, cons(y_3, y_4), x5, x6) IF_9(x0, x1, nil, cons(x3, x4), x5, x6, true) -> RING(x0, x1, nil, x4, x5, x6) IF_9(x0, x1, cons(y_2, y_3), cons(x3, x4), x5, x6, true) -> RING(x0, x1, cons(y_2, y_3), x4, x5, x6) IF_9(x0, x1, x2, cons(x3, x4), nil, x6, true) -> RING(x0, x1, x2, x4, nil, x6) IF_9(x0, x1, x2, cons(x3, x4), cons(y_4, y_5), x6, true) -> RING(x0, x1, x2, x4, cons(y_4, y_5), x6) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (150) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule RING(y0, y1, nil, y3, y4, y5) -> IF_2(y0, y1, nil, y3, y4, y5, leq(y5, 0)) we obtained the following new rules [LPAR04]: (RING(x0, cons(y_1, y_2), nil, x2, x3, x4) -> IF_2(x0, cons(y_1, y_2), nil, x2, x3, x4, leq(x4, 0)),RING(x0, cons(y_1, y_2), nil, x2, x3, x4) -> IF_2(x0, cons(y_1, y_2), nil, x2, x3, x4, leq(x4, 0))) ---------------------------------------- (151) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6) IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6) IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6) IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6) IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6) IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6) IF_9(x0, cons(y_1, y_2), x2, cons(x3, x4), x5, x6, true) -> RING(x0, cons(y_1, y_2), x2, x4, x5, x6) IF_9(x0, x1, x2, cons(x3, cons(y_3, y_4)), x5, x6, true) -> RING(x0, x1, x2, cons(y_3, y_4), x5, x6) IF_9(x0, x1, nil, cons(x3, x4), x5, x6, true) -> RING(x0, x1, nil, x4, x5, x6) IF_9(x0, x1, cons(y_2, y_3), cons(x3, x4), x5, x6, true) -> RING(x0, x1, cons(y_2, y_3), x4, x5, x6) IF_9(x0, x1, x2, cons(x3, x4), nil, x6, true) -> RING(x0, x1, x2, x4, nil, x6) IF_9(x0, x1, x2, cons(x3, x4), cons(y_4, y_5), x6, true) -> RING(x0, x1, x2, x4, cons(y_4, y_5), x6) RING(x0, cons(y_1, y_2), nil, x2, x3, x4) -> IF_2(x0, cons(y_1, y_2), nil, x2, x3, x4, leq(x4, 0)) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (152) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule RING(y0, y1, cons(x0, x1), y3, y4, y5) -> IF_2(y0, y1, cons(x0, x1), y3, y4, y5, leq(y5, s(length(x1)))) we obtained the following new rules [LPAR04]: (RING(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6) -> IF_2(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6, leq(x6, s(length(x3)))),RING(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6) -> IF_2(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6, leq(x6, s(length(x3))))) ---------------------------------------- (153) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6) IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6) IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6) IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6) IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6) IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6) IF_9(x0, cons(y_1, y_2), x2, cons(x3, x4), x5, x6, true) -> RING(x0, cons(y_1, y_2), x2, x4, x5, x6) IF_9(x0, x1, x2, cons(x3, cons(y_3, y_4)), x5, x6, true) -> RING(x0, x1, x2, cons(y_3, y_4), x5, x6) IF_9(x0, x1, nil, cons(x3, x4), x5, x6, true) -> RING(x0, x1, nil, x4, x5, x6) IF_9(x0, x1, cons(y_2, y_3), cons(x3, x4), x5, x6, true) -> RING(x0, x1, cons(y_2, y_3), x4, x5, x6) IF_9(x0, x1, x2, cons(x3, x4), nil, x6, true) -> RING(x0, x1, x2, x4, nil, x6) IF_9(x0, x1, x2, cons(x3, x4), cons(y_4, y_5), x6, true) -> RING(x0, x1, x2, x4, cons(y_4, y_5), x6) RING(x0, cons(y_1, y_2), nil, x2, x3, x4) -> IF_2(x0, cons(y_1, y_2), nil, x2, x3, x4, leq(x4, 0)) RING(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6) -> IF_2(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6, leq(x6, s(length(x3)))) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (154) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule RING(y0, y1, y2, y3, nil, y5) -> IF_6(y0, y1, y2, y3, nil, y5, leq(y5, 0)) we obtained the following new rules [LPAR04]: (RING(x0, x1, x2, cons(y_3, y_4), nil, x4) -> IF_6(x0, x1, x2, cons(y_3, y_4), nil, x4, leq(x4, 0)),RING(x0, x1, x2, cons(y_3, y_4), nil, x4) -> IF_6(x0, x1, x2, cons(y_3, y_4), nil, x4, leq(x4, 0))) ---------------------------------------- (155) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6) IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6) IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6) IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6) IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6) IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6) IF_9(x0, cons(y_1, y_2), x2, cons(x3, x4), x5, x6, true) -> RING(x0, cons(y_1, y_2), x2, x4, x5, x6) IF_9(x0, x1, x2, cons(x3, cons(y_3, y_4)), x5, x6, true) -> RING(x0, x1, x2, cons(y_3, y_4), x5, x6) IF_9(x0, x1, nil, cons(x3, x4), x5, x6, true) -> RING(x0, x1, nil, x4, x5, x6) IF_9(x0, x1, cons(y_2, y_3), cons(x3, x4), x5, x6, true) -> RING(x0, x1, cons(y_2, y_3), x4, x5, x6) IF_9(x0, x1, x2, cons(x3, x4), nil, x6, true) -> RING(x0, x1, x2, x4, nil, x6) IF_9(x0, x1, x2, cons(x3, x4), cons(y_4, y_5), x6, true) -> RING(x0, x1, x2, x4, cons(y_4, y_5), x6) RING(x0, cons(y_1, y_2), nil, x2, x3, x4) -> IF_2(x0, cons(y_1, y_2), nil, x2, x3, x4, leq(x4, 0)) RING(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6) -> IF_2(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6, leq(x6, s(length(x3)))) RING(x0, x1, x2, cons(y_3, y_4), nil, x4) -> IF_6(x0, x1, x2, cons(y_3, y_4), nil, x4, leq(x4, 0)) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (156) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule RING(y0, y1, y2, y3, cons(x0, x1), y5) -> IF_6(y0, y1, y2, y3, cons(x0, x1), y5, leq(y5, s(length(x1)))) we obtained the following new rules [LPAR04]: (RING(x0, x1, x2, cons(y_3, y_4), cons(x4, x5), x6) -> IF_6(x0, x1, x2, cons(y_3, y_4), cons(x4, x5), x6, leq(x6, s(length(x5)))),RING(x0, x1, x2, cons(y_3, y_4), cons(x4, x5), x6) -> IF_6(x0, x1, x2, cons(y_3, y_4), cons(x4, x5), x6, leq(x6, s(length(x5))))) ---------------------------------------- (157) Obligation: Q DP problem: The TRS P consists of the following rules: RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6) IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6) IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6) IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6) IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6) IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6) IF_9(x0, cons(y_1, y_2), x2, cons(x3, x4), x5, x6, true) -> RING(x0, cons(y_1, y_2), x2, x4, x5, x6) IF_9(x0, x1, x2, cons(x3, cons(y_3, y_4)), x5, x6, true) -> RING(x0, x1, x2, cons(y_3, y_4), x5, x6) IF_9(x0, x1, nil, cons(x3, x4), x5, x6, true) -> RING(x0, x1, nil, x4, x5, x6) IF_9(x0, x1, cons(y_2, y_3), cons(x3, x4), x5, x6, true) -> RING(x0, x1, cons(y_2, y_3), x4, x5, x6) IF_9(x0, x1, x2, cons(x3, x4), nil, x6, true) -> RING(x0, x1, x2, x4, nil, x6) IF_9(x0, x1, x2, cons(x3, x4), cons(y_4, y_5), x6, true) -> RING(x0, x1, x2, x4, cons(y_4, y_5), x6) RING(x0, cons(y_1, y_2), nil, x2, x3, x4) -> IF_2(x0, cons(y_1, y_2), nil, x2, x3, x4, leq(x4, 0)) RING(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6) -> IF_2(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6, leq(x6, s(length(x3)))) RING(x0, x1, x2, cons(y_3, y_4), nil, x4) -> IF_6(x0, x1, x2, cons(y_3, y_4), nil, x4, leq(x4, 0)) RING(x0, x1, x2, cons(y_3, y_4), cons(x4, x5), x6) -> IF_6(x0, x1, x2, cons(y_3, y_4), cons(x4, x5), x6, leq(x6, s(length(x5)))) The TRS R consists of the following rules: map_f(pid, nil) -> nil map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t)) app(nil, x) -> x app(cons(h, t), x) -> cons(h, app(t, x)) sndsplit(0, x) -> x sndsplit(s(n), nil) -> nil fstsplit(0, x) -> nil fstsplit(s(n), nil) -> nil fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t)) empty(nil) -> true empty(cons(h, t)) -> false length(nil) -> 0 length(cons(h, t)) -> s(length(t)) leq(0, m) -> true leq(s(n), s(m)) -> leq(n, m) leq(s(n), 0) -> false The set Q consists of the following terms: fstsplit(0, x0) fstsplit(s(x0), nil) fstsplit(s(x0), cons(x1, x2)) sndsplit(0, x0) sndsplit(s(x0), nil) sndsplit(s(x0), cons(x1, x2)) empty(nil) empty(cons(x0, x1)) leq(0, x0) leq(s(x0), 0) leq(s(x0), s(x1)) length(nil) length(cons(x0, x1)) app(nil, x0) app(cons(x0, x1), x2) map_f(x0, nil) map_f(x0, cons(x1, x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (158) QDPSizeChangeProof (EQUIVALENT) 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: *IF_4(z0, cons(z1, z2), nil, z3, z4, z5, false) -> RING(z0, z2, sndsplit(z5, app(map_f(two, z1), nil)), cons(fstsplit(z5, app(map_f(two, z1), nil)), z3), z4, z5) The graph contains the following edges 1 >= 1, 2 > 2, 5 >= 5, 6 >= 6 *RING(x0, cons(y_1, y_2), nil, x2, x3, x4) -> IF_2(x0, cons(y_1, y_2), nil, x2, x3, x4, leq(x4, 0)) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_2(z0, cons(x1, x2), nil, z2, z3, z4, false) -> IF_4(z0, cons(x1, x2), nil, z2, z3, z4, empty(fstsplit(z4, app(map_f(two, x1), nil)))) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_4(z0, cons(z1, z2), cons(z3, z4), z5, z6, z7, false) -> RING(z0, z2, sndsplit(z7, app(map_f(two, z1), cons(z3, z4))), cons(fstsplit(z7, app(map_f(two, z1), cons(z3, z4))), z5), z6, z7) The graph contains the following edges 1 >= 1, 2 > 2, 5 >= 5, 6 >= 6 *RING(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6) -> IF_2(x0, cons(y_1, y_2), cons(x2, x3), x4, x5, x6, leq(x6, s(length(x3)))) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_2(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, false) -> IF_4(z0, cons(x1, x2), cons(z2, z3), z4, z5, z6, empty(fstsplit(z6, app(map_f(two, x1), cons(z2, z3))))) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_8(z0, z1, z2, cons(z3, z4), nil, z5, false) -> RING(z0, z1, z2, z4, sndsplit(z5, app(map_f(three, z3), nil)), z5) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 6 >= 6 *IF_8(z0, z1, z2, cons(z3, z4), cons(z5, z6), z7, false) -> RING(z0, z1, z2, z4, sndsplit(z7, app(map_f(three, z3), cons(z5, z6))), z7) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 6 >= 6 *RING(x0, x1, x2, cons(y_3, y_4), nil, x4) -> IF_6(x0, x1, x2, cons(y_3, y_4), nil, x4, leq(x4, 0)) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_6(z0, z1, z2, cons(x3, x4), nil, z4, false) -> IF_8(z0, z1, z2, cons(x3, x4), nil, z4, empty(fstsplit(z4, app(map_f(three, x3), nil)))) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_6(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, false) -> IF_8(z0, z1, z2, cons(x3, x4), cons(z4, z5), z6, empty(fstsplit(z6, app(map_f(three, x3), cons(z4, z5))))) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *RING(x0, x1, x2, cons(y_3, y_4), cons(x4, x5), x6) -> IF_6(x0, x1, x2, cons(y_3, y_4), cons(x4, x5), x6, leq(x6, s(length(x5)))) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *RING(y0, cons(x0, x1), y2, y3, y4, y5) -> IF_5(y0, cons(x0, x1), y2, y3, y4, y5, empty(map_f(two, x0))) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *RING(y0, y1, y2, cons(x0, x1), y4, y5) -> IF_9(y0, y1, y2, cons(x0, x1), y4, y5, empty(map_f(three, x0))) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_5(x0, cons(x1, x2), cons(y_2, y_3), x4, x5, x6, true) -> RING(x0, x2, cons(y_2, y_3), x4, x5, x6) The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_9(x0, x1, cons(y_2, y_3), cons(x3, x4), x5, x6, true) -> RING(x0, x1, cons(y_2, y_3), x4, x5, x6) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 5 >= 5, 6 >= 6 *IF_5(x0, cons(x1, x2), nil, x4, x5, x6, true) -> RING(x0, x2, nil, x4, x5, x6) The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_9(x0, x1, nil, cons(x3, x4), x5, x6, true) -> RING(x0, x1, nil, x4, x5, x6) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 5 >= 5, 6 >= 6 *IF_5(x0, cons(x1, x2), x3, x4, cons(y_4, y_5), x6, true) -> RING(x0, x2, x3, x4, cons(y_4, y_5), x6) The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_9(x0, x1, x2, cons(x3, x4), cons(y_4, y_5), x6, true) -> RING(x0, x1, x2, x4, cons(y_4, y_5), x6) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 5 >= 5, 6 >= 6 *IF_5(x0, cons(x1, x2), x3, x4, nil, x6, true) -> RING(x0, x2, x3, x4, nil, x6) The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_9(x0, x1, x2, cons(x3, x4), nil, x6, true) -> RING(x0, x1, x2, x4, nil, x6) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 5 >= 5, 6 >= 6 *IF_5(x0, cons(x1, cons(y_1, y_2)), x3, x4, x5, x6, true) -> RING(x0, cons(y_1, y_2), x3, x4, x5, x6) The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_5(x0, cons(x1, x2), x3, cons(y_3, y_4), x5, x6, true) -> RING(x0, x2, x3, cons(y_3, y_4), x5, x6) The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 >= 6 *IF_9(x0, cons(y_1, y_2), x2, cons(x3, x4), x5, x6, true) -> RING(x0, cons(y_1, y_2), x2, x4, x5, x6) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 5 >= 5, 6 >= 6 *IF_9(x0, x1, x2, cons(x3, cons(y_3, y_4)), x5, x6, true) -> RING(x0, x1, x2, cons(y_3, y_4), x5, x6) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 5 >= 5, 6 >= 6 ---------------------------------------- (159) YES