/export/starexec/sandbox2/solver/bin/starexec_run_standard /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- YES proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml # AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty Termination w.r.t. Q of the given QTRS could be proven: (0) QTRS (1) QTRSRRRProof [EQUIVALENT, 175 ms] (2) QTRS (3) QTRSRRRProof [EQUIVALENT, 60 ms] (4) QTRS (5) QTRSRRRProof [EQUIVALENT, 30 ms] (6) QTRS (7) QTRSRRRProof [EQUIVALENT, 7 ms] (8) QTRS (9) QTRSRRRProof [EQUIVALENT, 2 ms] (10) QTRS (11) QTRSRRRProof [EQUIVALENT, 28 ms] (12) QTRS (13) QTRSRRRProof [EQUIVALENT, 34 ms] (14) QTRS (15) QTRSRRRProof [EQUIVALENT, 19 ms] (16) QTRS (17) QTRSRRRProof [EQUIVALENT, 18 ms] (18) QTRS (19) AAECC Innermost [EQUIVALENT, 0 ms] (20) QTRS (21) DependencyPairsProof [EQUIVALENT, 0 ms] (22) QDP (23) UsableRulesProof [EQUIVALENT, 0 ms] (24) QDP (25) QReductionProof [EQUIVALENT, 0 ms] (26) QDP (27) TransformationProof [EQUIVALENT, 0 ms] (28) QDP (29) TransformationProof [EQUIVALENT, 0 ms] (30) QDP (31) TransformationProof [EQUIVALENT, 0 ms] (32) QDP (33) TransformationProof [EQUIVALENT, 0 ms] (34) QDP (35) TransformationProof [EQUIVALENT, 0 ms] (36) QDP (37) TransformationProof [EQUIVALENT, 0 ms] (38) QDP (39) TransformationProof [EQUIVALENT, 0 ms] (40) QDP (41) TransformationProof [EQUIVALENT, 0 ms] (42) QDP (43) TransformationProof [EQUIVALENT, 0 ms] (44) QDP (45) TransformationProof [EQUIVALENT, 0 ms] (46) QDP (47) TransformationProof [EQUIVALENT, 0 ms] (48) QDP (49) TransformationProof [EQUIVALENT, 0 ms] (50) QDP (51) TransformationProof [EQUIVALENT, 0 ms] (52) QDP (53) TransformationProof [EQUIVALENT, 0 ms] (54) QDP (55) TransformationProof [EQUIVALENT, 0 ms] (56) QDP (57) TransformationProof [EQUIVALENT, 0 ms] (58) QDP (59) TransformationProof [EQUIVALENT, 0 ms] (60) QDP (61) TransformationProof [EQUIVALENT, 0 ms] (62) QDP (63) TransformationProof [EQUIVALENT, 0 ms] (64) QDP (65) TransformationProof [EQUIVALENT, 0 ms] (66) QDP (67) TransformationProof [EQUIVALENT, 0 ms] (68) QDP (69) DependencyGraphProof [EQUIVALENT, 0 ms] (70) QDP (71) TransformationProof [EQUIVALENT, 0 ms] (72) QDP (73) TransformationProof [EQUIVALENT, 0 ms] (74) QDP (75) TransformationProof [EQUIVALENT, 0 ms] (76) QDP (77) TransformationProof [EQUIVALENT, 0 ms] (78) QDP (79) DependencyGraphProof [EQUIVALENT, 0 ms] (80) QDP (81) TransformationProof [EQUIVALENT, 0 ms] (82) QDP (83) TransformationProof [EQUIVALENT, 0 ms] (84) QDP (85) TransformationProof [EQUIVALENT, 0 ms] (86) QDP (87) TransformationProof [EQUIVALENT, 0 ms] (88) QDP (89) TransformationProof [EQUIVALENT, 0 ms] (90) QDP (91) TransformationProof [EQUIVALENT, 0 ms] (92) QDP (93) DependencyGraphProof [EQUIVALENT, 0 ms] (94) TRUE ---------------------------------------- (0) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: start(i) -> busy(F, closed, stop, false, false, false, i) busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(fl, open, up, b1, b2, b3, i) -> incorrect busy(fl, open, down, b1, b2, b3, i) -> incorrect busy(B, closed, stop, false, false, false, empty) -> correct busy(F, closed, stop, false, false, false, empty) -> correct busy(S, closed, stop, false, false, false, empty) -> correct busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(B, open, stop, false, b2, b3, i) -> idle(B, closed, stop, false, b2, b3, i) busy(F, open, stop, b1, false, b3, i) -> idle(F, closed, stop, b1, false, b3, i) busy(S, open, stop, b1, b2, false, i) -> idle(S, closed, stop, b1, b2, false, i) busy(B, d, stop, true, b2, b3, i) -> idle(B, open, stop, false, b2, b3, i) busy(F, d, stop, b1, true, b3, i) -> idle(F, open, stop, b1, false, b3, i) busy(S, d, stop, b1, b2, true, i) -> idle(S, open, stop, b1, b2, false, i) busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) idle(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> busy(fl, d, m, or(b1, i1), or(b2, i2), or(b3, i3), i) or(true, b) -> true or(false, b) -> b Q is empty. ---------------------------------------- (1) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 0 POL(BF) = 0 POL(F) = 0 POL(FS) = 0 POL(S) = 0 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + 2*x_2 + x_3 + 2*x_4 + x_5 + 2*x_6 + 2*x_7 POL(closed) = 0 POL(correct) = 0 POL(down) = 0 POL(empty) = 0 POL(false) = 0 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + 2*x_2 + x_3 + 2*x_4 + x_5 + 2*x_6 + 2*x_7 POL(incorrect) = 0 POL(newbuttons(x_1, x_2, x_3, x_4)) = 2*x_1 + x_2 + 2*x_3 + x_4 POL(open) = 0 POL(or(x_1, x_2)) = x_1 + 2*x_2 POL(start(x_1)) = 2 + 2*x_1 POL(stop) = 0 POL(true) = 0 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: start(i) -> busy(F, closed, stop, false, false, false, i) ---------------------------------------- (2) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(fl, open, up, b1, b2, b3, i) -> incorrect busy(fl, open, down, b1, b2, b3, i) -> incorrect busy(B, closed, stop, false, false, false, empty) -> correct busy(F, closed, stop, false, false, false, empty) -> correct busy(S, closed, stop, false, false, false, empty) -> correct busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(B, open, stop, false, b2, b3, i) -> idle(B, closed, stop, false, b2, b3, i) busy(F, open, stop, b1, false, b3, i) -> idle(F, closed, stop, b1, false, b3, i) busy(S, open, stop, b1, b2, false, i) -> idle(S, closed, stop, b1, b2, false, i) busy(B, d, stop, true, b2, b3, i) -> idle(B, open, stop, false, b2, b3, i) busy(F, d, stop, b1, true, b3, i) -> idle(F, open, stop, b1, false, b3, i) busy(S, d, stop, b1, b2, true, i) -> idle(S, open, stop, b1, b2, false, i) busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) idle(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> busy(fl, d, m, or(b1, i1), or(b2, i2), or(b3, i3), i) or(true, b) -> true or(false, b) -> b Q is empty. ---------------------------------------- (3) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 0 POL(BF) = 0 POL(F) = 0 POL(FS) = 0 POL(S) = 0 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = x_1 + x_2 + 2*x_3 + 2*x_4 + x_5 + x_6 + 2*x_7 POL(closed) = 0 POL(correct) = 0 POL(down) = 0 POL(empty) = 0 POL(false) = 0 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + 2*x_2 + 2*x_3 + 2*x_4 + x_5 + x_6 + 2*x_7 POL(incorrect) = 0 POL(newbuttons(x_1, x_2, x_3, x_4)) = x_1 + 2*x_2 + x_3 + x_4 POL(open) = 0 POL(or(x_1, x_2)) = x_1 + x_2 POL(stop) = 0 POL(true) = 1 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: busy(B, d, stop, true, b2, b3, i) -> idle(B, open, stop, false, b2, b3, i) busy(F, d, stop, b1, true, b3, i) -> idle(F, open, stop, b1, false, b3, i) busy(S, d, stop, b1, b2, true, i) -> idle(S, open, stop, b1, b2, false, i) ---------------------------------------- (4) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(fl, open, up, b1, b2, b3, i) -> incorrect busy(fl, open, down, b1, b2, b3, i) -> incorrect busy(B, closed, stop, false, false, false, empty) -> correct busy(F, closed, stop, false, false, false, empty) -> correct busy(S, closed, stop, false, false, false, empty) -> correct busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(B, open, stop, false, b2, b3, i) -> idle(B, closed, stop, false, b2, b3, i) busy(F, open, stop, b1, false, b3, i) -> idle(F, closed, stop, b1, false, b3, i) busy(S, open, stop, b1, b2, false, i) -> idle(S, closed, stop, b1, b2, false, i) busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) idle(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> busy(fl, d, m, or(b1, i1), or(b2, i2), or(b3, i3), i) or(true, b) -> true or(false, b) -> b Q is empty. ---------------------------------------- (5) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 0 POL(BF) = 0 POL(F) = 0 POL(FS) = 0 POL(S) = 0 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + 2*x_2 + x_3 + 2*x_4 + x_5 + x_6 + 2*x_7 POL(closed) = 0 POL(correct) = 1 POL(down) = 0 POL(empty) = 1 POL(false) = 0 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + 2*x_2 + 2*x_3 + 2*x_4 + x_5 + x_6 + 2*x_7 POL(incorrect) = 0 POL(newbuttons(x_1, x_2, x_3, x_4)) = 2*x_1 + x_2 + x_3 + 2*x_4 POL(open) = 0 POL(or(x_1, x_2)) = x_1 + x_2 POL(stop) = 0 POL(true) = 1 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: busy(B, closed, stop, false, false, false, empty) -> correct busy(F, closed, stop, false, false, false, empty) -> correct busy(S, closed, stop, false, false, false, empty) -> correct ---------------------------------------- (6) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(fl, open, up, b1, b2, b3, i) -> incorrect busy(fl, open, down, b1, b2, b3, i) -> incorrect busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(B, open, stop, false, b2, b3, i) -> idle(B, closed, stop, false, b2, b3, i) busy(F, open, stop, b1, false, b3, i) -> idle(F, closed, stop, b1, false, b3, i) busy(S, open, stop, b1, b2, false, i) -> idle(S, closed, stop, b1, b2, false, i) busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) idle(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> busy(fl, d, m, or(b1, i1), or(b2, i2), or(b3, i3), i) or(true, b) -> true or(false, b) -> b Q is empty. ---------------------------------------- (7) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 0 POL(BF) = 0 POL(F) = 0 POL(FS) = 0 POL(S) = 0 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + x_2 + x_3 + x_4 + x_5 + x_6 + x_7 POL(closed) = 0 POL(down) = 0 POL(empty) = 0 POL(false) = 2 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + 2*x_2 + x_3 + x_4 + x_5 + x_6 + x_7 POL(incorrect) = 0 POL(newbuttons(x_1, x_2, x_3, x_4)) = 2*x_1 + 2*x_2 + x_3 + x_4 POL(open) = 0 POL(or(x_1, x_2)) = x_1 + x_2 POL(stop) = 0 POL(true) = 2 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: or(false, b) -> b ---------------------------------------- (8) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(fl, open, up, b1, b2, b3, i) -> incorrect busy(fl, open, down, b1, b2, b3, i) -> incorrect busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(B, open, stop, false, b2, b3, i) -> idle(B, closed, stop, false, b2, b3, i) busy(F, open, stop, b1, false, b3, i) -> idle(F, closed, stop, b1, false, b3, i) busy(S, open, stop, b1, b2, false, i) -> idle(S, closed, stop, b1, b2, false, i) busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) idle(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> busy(fl, d, m, or(b1, i1), or(b2, i2), or(b3, i3), i) or(true, b) -> true Q is empty. ---------------------------------------- (9) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 0 POL(BF) = 0 POL(F) = 0 POL(FS) = 0 POL(S) = 0 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + x_2 + x_3 + 2*x_4 + x_5 + x_6 + 2*x_7 POL(closed) = 0 POL(down) = 0 POL(empty) = 0 POL(false) = 0 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + x_2 + 2*x_3 + 2*x_4 + x_5 + x_6 + 2*x_7 POL(incorrect) = 0 POL(newbuttons(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3 + x_4 POL(open) = 2 POL(or(x_1, x_2)) = x_1 + x_2 POL(stop) = 0 POL(true) = 1 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: busy(fl, open, up, b1, b2, b3, i) -> incorrect busy(fl, open, down, b1, b2, b3, i) -> incorrect busy(B, open, stop, false, b2, b3, i) -> idle(B, closed, stop, false, b2, b3, i) busy(F, open, stop, b1, false, b3, i) -> idle(F, closed, stop, b1, false, b3, i) busy(S, open, stop, b1, b2, false, i) -> idle(S, closed, stop, b1, b2, false, i) ---------------------------------------- (10) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) idle(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> busy(fl, d, m, or(b1, i1), or(b2, i2), or(b3, i3), i) or(true, b) -> true Q is empty. ---------------------------------------- (11) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 0 POL(BF) = 0 POL(F) = 0 POL(FS) = 0 POL(S) = 0 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = x_1 + 2*x_2 + x_3 + x_4 + 2*x_5 + 2*x_6 + x_7 POL(closed) = 0 POL(down) = 0 POL(empty) = 0 POL(false) = 0 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + 2*x_2 + x_3 + x_4 + 2*x_5 + 2*x_6 + x_7 POL(incorrect) = 0 POL(newbuttons(x_1, x_2, x_3, x_4)) = 1 + 2*x_1 + 2*x_2 + 2*x_3 + 2*x_4 POL(or(x_1, x_2)) = x_1 + x_2 POL(stop) = 0 POL(true) = 0 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: idle(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> busy(fl, d, m, or(b1, i1), or(b2, i2), or(b3, i3), i) ---------------------------------------- (12) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) or(true, b) -> true Q is empty. ---------------------------------------- (13) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 0 POL(BF) = 0 POL(F) = 0 POL(FS) = 0 POL(S) = 0 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = x_1 + x_2 + x_3 + x_4 + x_5 + x_6 + x_7 POL(closed) = 0 POL(down) = 0 POL(empty) = 0 POL(false) = 0 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = x_1 + x_2 + x_3 + x_4 + x_5 + x_6 + x_7 POL(incorrect) = 0 POL(newbuttons(x_1, x_2, x_3, x_4)) = x_1 + x_2 + 2*x_3 + 2*x_4 POL(or(x_1, x_2)) = 1 + 2*x_1 + x_2 POL(stop) = 0 POL(true) = 2 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: or(true, b) -> true ---------------------------------------- (14) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) Q is empty. ---------------------------------------- (15) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 0 POL(BF) = 0 POL(F) = 0 POL(FS) = 0 POL(S) = 0 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = x_1 + x_2 + x_3 + x_4 + x_5 + x_6 + 2*x_7 POL(closed) = 0 POL(down) = 0 POL(empty) = 0 POL(false) = 0 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = 2*x_1 + 2*x_2 + x_3 + x_4 + x_5 + x_6 + x_7 POL(incorrect) = 0 POL(newbuttons(x_1, x_2, x_3, x_4)) = 1 + 2*x_1 + 2*x_2 + 2*x_3 + 2*x_4 POL(stop) = 0 POL(true) = 0 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: busy(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) busy(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> idle(S, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) ---------------------------------------- (16) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) Q is empty. ---------------------------------------- (17) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(B) = 1 POL(BF) = 1 POL(F) = 1 POL(FS) = 1 POL(S) = 1 POL(busy(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = x_1 + x_2 + x_3 + x_4 + x_5 + x_6 + 2*x_7 POL(closed) = 0 POL(down) = 0 POL(empty) = 0 POL(false) = 0 POL(idle(x_1, x_2, x_3, x_4, x_5, x_6, x_7)) = x_1 + x_2 + x_3 + x_4 + x_5 + x_6 + x_7 POL(incorrect) = 0 POL(stop) = 0 POL(true) = 0 POL(up) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: busy(BF, d, stop, b1, b2, b3, i) -> incorrect busy(FS, d, stop, b1, b2, b3, i) -> incorrect ---------------------------------------- (18) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) Q is empty. ---------------------------------------- (19) AAECC Innermost (EQUIVALENT) We have applied [NOC,AAECCNOC] to switch to innermost. The TRS R 1 is none The TRS R 2 is busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) The signature Sigma is {busy_7, idle_7} ---------------------------------------- (20) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) The set Q consists of the following terms: busy(B, closed, down, x0, x1, x2, x3) busy(S, closed, up, x0, x1, x2, x3) busy(B, closed, up, true, x0, x1, x2) busy(F, closed, up, x0, true, x1, x2) busy(F, closed, down, x0, true, x1, x2) busy(S, closed, down, x0, x1, true, x2) busy(B, closed, up, false, x0, x1, x2) busy(F, closed, up, x0, false, x1, x2) busy(F, closed, down, x0, false, x1, x2) busy(S, closed, down, x0, x1, false, x2) busy(BF, closed, up, x0, x1, x2, x3) busy(BF, closed, down, x0, x1, x2, x3) busy(FS, closed, up, x0, x1, x2, x3) busy(FS, closed, down, x0, x1, x2, x3) busy(B, closed, stop, false, true, x0, x1) busy(B, closed, stop, false, false, true, x0) busy(F, closed, stop, true, false, x0, x1) busy(F, closed, stop, false, false, true, x0) busy(S, closed, stop, x0, true, false, x1) busy(S, closed, stop, true, false, false, x0) idle(x0, x1, x2, x3, x4, x5, empty) ---------------------------------------- (21) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem. ---------------------------------------- (22) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i) BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i) BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i) BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) The TRS R consists of the following rules: busy(B, closed, down, b1, b2, b3, i) -> idle(B, closed, stop, b1, b2, b3, i) busy(S, closed, up, b1, b2, b3, i) -> idle(S, closed, stop, b1, b2, b3, i) busy(B, closed, up, true, b2, b3, i) -> idle(B, closed, stop, true, b2, b3, i) busy(F, closed, up, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(F, closed, down, b1, true, b3, i) -> idle(F, closed, stop, b1, true, b3, i) busy(S, closed, down, b1, b2, true, i) -> idle(S, closed, stop, b1, b2, true, i) busy(B, closed, up, false, b2, b3, i) -> idle(BF, closed, up, false, b2, b3, i) busy(F, closed, up, b1, false, b3, i) -> idle(FS, closed, up, b1, false, b3, i) busy(F, closed, down, b1, false, b3, i) -> idle(BF, closed, down, b1, false, b3, i) busy(S, closed, down, b1, b2, false, i) -> idle(FS, closed, down, b1, b2, false, i) busy(BF, closed, up, b1, b2, b3, i) -> idle(F, closed, up, b1, b2, b3, i) busy(BF, closed, down, b1, b2, b3, i) -> idle(B, closed, down, b1, b2, b3, i) busy(FS, closed, up, b1, b2, b3, i) -> idle(S, closed, up, b1, b2, b3, i) busy(FS, closed, down, b1, b2, b3, i) -> idle(F, closed, down, b1, b2, b3, i) busy(B, closed, stop, false, true, b3, i) -> idle(B, closed, up, false, true, b3, i) busy(B, closed, stop, false, false, true, i) -> idle(B, closed, up, false, false, true, i) busy(F, closed, stop, true, false, b3, i) -> idle(F, closed, down, true, false, b3, i) busy(F, closed, stop, false, false, true, i) -> idle(F, closed, up, false, false, true, i) busy(S, closed, stop, b1, true, false, i) -> idle(S, closed, down, b1, true, false, i) busy(S, closed, stop, true, false, false, i) -> idle(S, closed, down, true, false, false, i) idle(fl, d, m, b1, b2, b3, empty) -> busy(fl, d, m, b1, b2, b3, empty) The set Q consists of the following terms: busy(B, closed, down, x0, x1, x2, x3) busy(S, closed, up, x0, x1, x2, x3) busy(B, closed, up, true, x0, x1, x2) busy(F, closed, up, x0, true, x1, x2) busy(F, closed, down, x0, true, x1, x2) busy(S, closed, down, x0, x1, true, x2) busy(B, closed, up, false, x0, x1, x2) busy(F, closed, up, x0, false, x1, x2) busy(F, closed, down, x0, false, x1, x2) busy(S, closed, down, x0, x1, false, x2) busy(BF, closed, up, x0, x1, x2, x3) busy(BF, closed, down, x0, x1, x2, x3) busy(FS, closed, up, x0, x1, x2, x3) busy(FS, closed, down, x0, x1, x2, x3) busy(B, closed, stop, false, true, x0, x1) busy(B, closed, stop, false, false, true, x0) busy(F, closed, stop, true, false, x0, x1) busy(F, closed, stop, false, false, true, x0) busy(S, closed, stop, x0, true, false, x1) busy(S, closed, stop, true, false, false, x0) idle(x0, x1, x2, x3, x4, x5, empty) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (23) 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. ---------------------------------------- (24) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i) BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i) BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i) BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) R is empty. The set Q consists of the following terms: busy(B, closed, down, x0, x1, x2, x3) busy(S, closed, up, x0, x1, x2, x3) busy(B, closed, up, true, x0, x1, x2) busy(F, closed, up, x0, true, x1, x2) busy(F, closed, down, x0, true, x1, x2) busy(S, closed, down, x0, x1, true, x2) busy(B, closed, up, false, x0, x1, x2) busy(F, closed, up, x0, false, x1, x2) busy(F, closed, down, x0, false, x1, x2) busy(S, closed, down, x0, x1, false, x2) busy(BF, closed, up, x0, x1, x2, x3) busy(BF, closed, down, x0, x1, x2, x3) busy(FS, closed, up, x0, x1, x2, x3) busy(FS, closed, down, x0, x1, x2, x3) busy(B, closed, stop, false, true, x0, x1) busy(B, closed, stop, false, false, true, x0) busy(F, closed, stop, true, false, x0, x1) busy(F, closed, stop, false, false, true, x0) busy(S, closed, stop, x0, true, false, x1) busy(S, closed, stop, true, false, false, x0) idle(x0, x1, x2, x3, x4, x5, empty) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (25) 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]. busy(B, closed, down, x0, x1, x2, x3) busy(S, closed, up, x0, x1, x2, x3) busy(B, closed, up, true, x0, x1, x2) busy(F, closed, up, x0, true, x1, x2) busy(F, closed, down, x0, true, x1, x2) busy(S, closed, down, x0, x1, true, x2) busy(B, closed, up, false, x0, x1, x2) busy(F, closed, up, x0, false, x1, x2) busy(F, closed, down, x0, false, x1, x2) busy(S, closed, down, x0, x1, false, x2) busy(BF, closed, up, x0, x1, x2, x3) busy(BF, closed, down, x0, x1, x2, x3) busy(FS, closed, up, x0, x1, x2, x3) busy(FS, closed, down, x0, x1, x2, x3) busy(B, closed, stop, false, true, x0, x1) busy(B, closed, stop, false, false, true, x0) busy(F, closed, stop, true, false, x0, x1) busy(F, closed, stop, false, false, true, x0) busy(S, closed, stop, x0, true, false, x1) busy(S, closed, stop, true, false, false, x0) idle(x0, x1, x2, x3, x4, x5, empty) ---------------------------------------- (26) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i) BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i) BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i) BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (27) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i) we obtained the following new rules [LPAR04]: (BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty),BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty)) ---------------------------------------- (28) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i) BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i) BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (29) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i) we obtained the following new rules [LPAR04]: (BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty),BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty)) ---------------------------------------- (30) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i) BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (31) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i) we obtained the following new rules [LPAR04]: (BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty),BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty)) ---------------------------------------- (32) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (33) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) we obtained the following new rules [LPAR04]: (BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty),BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty)) ---------------------------------------- (34) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (35) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i) we obtained the following new rules [LPAR04]: (BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty),BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty)) ---------------------------------------- (36) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (37) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i) we obtained the following new rules [LPAR04]: (BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty),BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty)) ---------------------------------------- (38) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (39) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i) we obtained the following new rules [LPAR04]: (BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty),BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty)) ---------------------------------------- (40) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (41) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i) we obtained the following new rules [LPAR04]: (BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty),BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty)) ---------------------------------------- (42) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (43) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i) we obtained the following new rules [LPAR04]: (BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty),BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty)) ---------------------------------------- (44) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (45) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i) we obtained the following new rules [LPAR04]: (BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty),BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty)) ---------------------------------------- (46) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (47) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i) we obtained the following new rules [LPAR04]: (BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty),BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty)) ---------------------------------------- (48) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (49) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i) we obtained the following new rules [LPAR04]: (BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty),BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty)) ---------------------------------------- (50) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (51) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i) we obtained the following new rules [LPAR04]: (BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty),BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty)) ---------------------------------------- (52) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (53) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i) we obtained the following new rules [LPAR04]: (BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty),BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty)) ---------------------------------------- (54) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (55) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i) we obtained the following new rules [LPAR04]: (BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty),BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty)) ---------------------------------------- (56) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (57) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i) we obtained the following new rules [LPAR04]: (BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty),BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty)) ---------------------------------------- (58) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (59) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i) we obtained the following new rules [LPAR04]: (BUSY(F, closed, stop, true, false, z5, empty) -> IDLE(F, closed, down, true, false, z5, empty),BUSY(F, closed, stop, true, false, z5, empty) -> IDLE(F, closed, down, true, false, z5, empty)) ---------------------------------------- (60) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) BUSY(F, closed, stop, true, false, z5, empty) -> IDLE(F, closed, down, true, false, z5, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (61) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i) we obtained the following new rules [LPAR04]: (BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty),BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty)) ---------------------------------------- (62) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) BUSY(F, closed, stop, true, false, z5, empty) -> IDLE(F, closed, down, true, false, z5, empty) BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (63) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i) we obtained the following new rules [LPAR04]: (BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty),BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty)) ---------------------------------------- (64) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) BUSY(F, closed, stop, true, false, z5, empty) -> IDLE(F, closed, down, true, false, z5, empty) BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (65) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i) we obtained the following new rules [LPAR04]: (BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty),BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty)) ---------------------------------------- (66) Obligation: Q DP problem: The TRS P consists of the following rules: IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) BUSY(F, closed, stop, true, false, z5, empty) -> IDLE(F, closed, down, true, false, z5, empty) BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (67) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty) we obtained the following new rules [LPAR04]: (IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty),IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty)) (IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty),IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty)) (IDLE(B, closed, stop, true, z0, z1, empty) -> BUSY(B, closed, stop, true, z0, z1, empty),IDLE(B, closed, stop, true, z0, z1, empty) -> BUSY(B, closed, stop, true, z0, z1, empty)) (IDLE(F, closed, stop, z0, true, z1, empty) -> BUSY(F, closed, stop, z0, true, z1, empty),IDLE(F, closed, stop, z0, true, z1, empty) -> BUSY(F, closed, stop, z0, true, z1, empty)) (IDLE(S, closed, stop, z0, z1, true, empty) -> BUSY(S, closed, stop, z0, z1, true, empty),IDLE(S, closed, stop, z0, z1, true, empty) -> BUSY(S, closed, stop, z0, z1, true, empty)) (IDLE(BF, closed, up, false, z0, z1, empty) -> BUSY(BF, closed, up, false, z0, z1, empty),IDLE(BF, closed, up, false, z0, z1, empty) -> BUSY(BF, closed, up, false, z0, z1, empty)) (IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty),IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty)) (IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty),IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty)) (IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty),IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty)) (IDLE(F, closed, up, z0, z1, z2, empty) -> BUSY(F, closed, up, z0, z1, z2, empty),IDLE(F, closed, up, z0, z1, z2, empty) -> BUSY(F, closed, up, z0, z1, z2, empty)) (IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty),IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty)) (IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty),IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty)) (IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty),IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty)) (IDLE(B, closed, up, false, true, z0, empty) -> BUSY(B, closed, up, false, true, z0, empty),IDLE(B, closed, up, false, true, z0, empty) -> BUSY(B, closed, up, false, true, z0, empty)) (IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty),IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty)) (IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty),IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty)) (IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty),IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty)) (IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty),IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty)) (IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty),IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty)) ---------------------------------------- (68) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) BUSY(B, closed, up, true, z4, z5, empty) -> IDLE(B, closed, stop, true, z4, z5, empty) BUSY(F, closed, up, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(F, closed, down, z3, true, z5, empty) -> IDLE(F, closed, stop, z3, true, z5, empty) BUSY(S, closed, down, z3, z4, true, empty) -> IDLE(S, closed, stop, z3, z4, true, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) BUSY(F, closed, stop, true, false, z5, empty) -> IDLE(F, closed, down, true, false, z5, empty) BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) IDLE(B, closed, stop, true, z0, z1, empty) -> BUSY(B, closed, stop, true, z0, z1, empty) IDLE(F, closed, stop, z0, true, z1, empty) -> BUSY(F, closed, stop, z0, true, z1, empty) IDLE(S, closed, stop, z0, z1, true, empty) -> BUSY(S, closed, stop, z0, z1, true, empty) IDLE(BF, closed, up, false, z0, z1, empty) -> BUSY(BF, closed, up, false, z0, z1, empty) IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) IDLE(F, closed, up, z0, z1, z2, empty) -> BUSY(F, closed, up, z0, z1, z2, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) IDLE(B, closed, up, false, true, z0, empty) -> BUSY(B, closed, up, false, true, z0, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (69) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 9 less nodes. ---------------------------------------- (70) Obligation: Q DP problem: The TRS P consists of the following rules: IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) IDLE(B, closed, up, false, true, z0, empty) -> BUSY(B, closed, up, false, true, z0, empty) BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) IDLE(BF, closed, up, false, z0, z1, empty) -> BUSY(BF, closed, up, false, z0, z1, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) IDLE(F, closed, up, z0, z1, z2, empty) -> BUSY(F, closed, up, z0, z1, z2, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (71) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(B, closed, up, false, z4, z5, empty) -> IDLE(BF, closed, up, false, z4, z5, empty) we obtained the following new rules [LPAR04]: (BUSY(B, closed, up, false, true, z0, empty) -> IDLE(BF, closed, up, false, true, z0, empty),BUSY(B, closed, up, false, true, z0, empty) -> IDLE(BF, closed, up, false, true, z0, empty)) (BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty),BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty)) ---------------------------------------- (72) Obligation: Q DP problem: The TRS P consists of the following rules: IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) IDLE(B, closed, up, false, true, z0, empty) -> BUSY(B, closed, up, false, true, z0, empty) IDLE(BF, closed, up, false, z0, z1, empty) -> BUSY(BF, closed, up, false, z0, z1, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) IDLE(F, closed, up, z0, z1, z2, empty) -> BUSY(F, closed, up, z0, z1, z2, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, true, z0, empty) -> IDLE(BF, closed, up, false, true, z0, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (73) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IDLE(BF, closed, up, false, z0, z1, empty) -> BUSY(BF, closed, up, false, z0, z1, empty) we obtained the following new rules [LPAR04]: (IDLE(BF, closed, up, false, true, z0, empty) -> BUSY(BF, closed, up, false, true, z0, empty),IDLE(BF, closed, up, false, true, z0, empty) -> BUSY(BF, closed, up, false, true, z0, empty)) (IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty),IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty)) ---------------------------------------- (74) Obligation: Q DP problem: The TRS P consists of the following rules: IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) IDLE(B, closed, up, false, true, z0, empty) -> BUSY(B, closed, up, false, true, z0, empty) BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) IDLE(F, closed, up, z0, z1, z2, empty) -> BUSY(F, closed, up, z0, z1, z2, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, true, z0, empty) -> IDLE(BF, closed, up, false, true, z0, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, true, z0, empty) -> BUSY(BF, closed, up, false, true, z0, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (75) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(BF, closed, up, z3, z4, z5, empty) -> IDLE(F, closed, up, z3, z4, z5, empty) we obtained the following new rules [LPAR04]: (BUSY(BF, closed, up, false, true, z0, empty) -> IDLE(F, closed, up, false, true, z0, empty),BUSY(BF, closed, up, false, true, z0, empty) -> IDLE(F, closed, up, false, true, z0, empty)) (BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty),BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty)) ---------------------------------------- (76) Obligation: Q DP problem: The TRS P consists of the following rules: IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) IDLE(B, closed, up, false, true, z0, empty) -> BUSY(B, closed, up, false, true, z0, empty) IDLE(F, closed, up, z0, z1, z2, empty) -> BUSY(F, closed, up, z0, z1, z2, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, true, z0, empty) -> IDLE(BF, closed, up, false, true, z0, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, true, z0, empty) -> BUSY(BF, closed, up, false, true, z0, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, true, z0, empty) -> IDLE(F, closed, up, false, true, z0, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (77) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IDLE(F, closed, up, z0, z1, z2, empty) -> BUSY(F, closed, up, z0, z1, z2, empty) we obtained the following new rules [LPAR04]: (IDLE(F, closed, up, false, true, z0, empty) -> BUSY(F, closed, up, false, true, z0, empty),IDLE(F, closed, up, false, true, z0, empty) -> BUSY(F, closed, up, false, true, z0, empty)) (IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty),IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty)) ---------------------------------------- (78) Obligation: Q DP problem: The TRS P consists of the following rules: IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) BUSY(B, closed, stop, false, true, z5, empty) -> IDLE(B, closed, up, false, true, z5, empty) IDLE(B, closed, up, false, true, z0, empty) -> BUSY(B, closed, up, false, true, z0, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, true, z0, empty) -> IDLE(BF, closed, up, false, true, z0, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, true, z0, empty) -> BUSY(BF, closed, up, false, true, z0, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, true, z0, empty) -> IDLE(F, closed, up, false, true, z0, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) IDLE(F, closed, up, false, true, z0, empty) -> BUSY(F, closed, up, false, true, z0, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (79) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 6 less nodes. ---------------------------------------- (80) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (81) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(F, closed, up, z3, false, z5, empty) -> IDLE(FS, closed, up, z3, false, z5, empty) we obtained the following new rules [LPAR04]: (BUSY(F, closed, up, false, false, true, empty) -> IDLE(FS, closed, up, false, false, true, empty),BUSY(F, closed, up, false, false, true, empty) -> IDLE(FS, closed, up, false, false, true, empty)) ---------------------------------------- (82) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) BUSY(F, closed, up, false, false, true, empty) -> IDLE(FS, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (83) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IDLE(FS, closed, up, z0, false, z1, empty) -> BUSY(FS, closed, up, z0, false, z1, empty) we obtained the following new rules [LPAR04]: (IDLE(FS, closed, up, false, false, true, empty) -> BUSY(FS, closed, up, false, false, true, empty),IDLE(FS, closed, up, false, false, true, empty) -> BUSY(FS, closed, up, false, false, true, empty)) ---------------------------------------- (84) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) BUSY(F, closed, up, false, false, true, empty) -> IDLE(FS, closed, up, false, false, true, empty) IDLE(FS, closed, up, false, false, true, empty) -> BUSY(FS, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (85) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(FS, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, up, z3, z4, z5, empty) we obtained the following new rules [LPAR04]: (BUSY(FS, closed, up, false, false, true, empty) -> IDLE(S, closed, up, false, false, true, empty),BUSY(FS, closed, up, false, false, true, empty) -> IDLE(S, closed, up, false, false, true, empty)) ---------------------------------------- (86) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) BUSY(F, closed, up, false, false, true, empty) -> IDLE(FS, closed, up, false, false, true, empty) IDLE(FS, closed, up, false, false, true, empty) -> BUSY(FS, closed, up, false, false, true, empty) BUSY(FS, closed, up, false, false, true, empty) -> IDLE(S, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (87) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IDLE(S, closed, up, z0, z1, z2, empty) -> BUSY(S, closed, up, z0, z1, z2, empty) we obtained the following new rules [LPAR04]: (IDLE(S, closed, up, false, false, true, empty) -> BUSY(S, closed, up, false, false, true, empty),IDLE(S, closed, up, false, false, true, empty) -> BUSY(S, closed, up, false, false, true, empty)) ---------------------------------------- (88) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) BUSY(F, closed, up, false, false, true, empty) -> IDLE(FS, closed, up, false, false, true, empty) IDLE(FS, closed, up, false, false, true, empty) -> BUSY(FS, closed, up, false, false, true, empty) BUSY(FS, closed, up, false, false, true, empty) -> IDLE(S, closed, up, false, false, true, empty) IDLE(S, closed, up, false, false, true, empty) -> BUSY(S, closed, up, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (89) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule BUSY(S, closed, up, z3, z4, z5, empty) -> IDLE(S, closed, stop, z3, z4, z5, empty) we obtained the following new rules [LPAR04]: (BUSY(S, closed, up, false, false, true, empty) -> IDLE(S, closed, stop, false, false, true, empty),BUSY(S, closed, up, false, false, true, empty) -> IDLE(S, closed, stop, false, false, true, empty)) ---------------------------------------- (90) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) BUSY(F, closed, up, false, false, true, empty) -> IDLE(FS, closed, up, false, false, true, empty) IDLE(FS, closed, up, false, false, true, empty) -> BUSY(FS, closed, up, false, false, true, empty) BUSY(FS, closed, up, false, false, true, empty) -> IDLE(S, closed, up, false, false, true, empty) IDLE(S, closed, up, false, false, true, empty) -> BUSY(S, closed, up, false, false, true, empty) BUSY(S, closed, up, false, false, true, empty) -> IDLE(S, closed, stop, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (91) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IDLE(S, closed, stop, z0, z1, z2, empty) -> BUSY(S, closed, stop, z0, z1, z2, empty) we obtained the following new rules [LPAR04]: (IDLE(S, closed, stop, false, false, true, empty) -> BUSY(S, closed, stop, false, false, true, empty),IDLE(S, closed, stop, false, false, true, empty) -> BUSY(S, closed, stop, false, false, true, empty)) ---------------------------------------- (92) Obligation: Q DP problem: The TRS P consists of the following rules: BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty) IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty) BUSY(B, closed, up, false, false, true, empty) -> IDLE(BF, closed, up, false, false, true, empty) IDLE(BF, closed, up, false, false, true, empty) -> BUSY(BF, closed, up, false, false, true, empty) BUSY(BF, closed, up, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty) IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty) BUSY(S, closed, stop, z3, true, false, empty) -> IDLE(S, closed, down, z3, true, false, empty) IDLE(S, closed, down, z0, true, false, empty) -> BUSY(S, closed, down, z0, true, false, empty) BUSY(S, closed, down, z3, z4, false, empty) -> IDLE(FS, closed, down, z3, z4, false, empty) IDLE(FS, closed, down, z0, z1, false, empty) -> BUSY(FS, closed, down, z0, z1, false, empty) BUSY(FS, closed, down, z3, z4, z5, empty) -> IDLE(F, closed, down, z3, z4, z5, empty) IDLE(F, closed, down, z0, z1, z2, empty) -> BUSY(F, closed, down, z0, z1, z2, empty) BUSY(F, closed, down, z3, false, z5, empty) -> IDLE(BF, closed, down, z3, false, z5, empty) IDLE(BF, closed, down, z0, false, z1, empty) -> BUSY(BF, closed, down, z0, false, z1, empty) BUSY(BF, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, down, z3, z4, z5, empty) IDLE(B, closed, down, z0, z1, z2, empty) -> BUSY(B, closed, down, z0, z1, z2, empty) BUSY(B, closed, down, z3, z4, z5, empty) -> IDLE(B, closed, stop, z3, z4, z5, empty) IDLE(B, closed, stop, z0, z1, z2, empty) -> BUSY(B, closed, stop, z0, z1, z2, empty) IDLE(F, closed, down, true, false, z0, empty) -> BUSY(F, closed, down, true, false, z0, empty) BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty) IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty) BUSY(F, closed, up, false, false, true, empty) -> IDLE(FS, closed, up, false, false, true, empty) IDLE(FS, closed, up, false, false, true, empty) -> BUSY(FS, closed, up, false, false, true, empty) BUSY(FS, closed, up, false, false, true, empty) -> IDLE(S, closed, up, false, false, true, empty) IDLE(S, closed, up, false, false, true, empty) -> BUSY(S, closed, up, false, false, true, empty) BUSY(S, closed, up, false, false, true, empty) -> IDLE(S, closed, stop, false, false, true, empty) IDLE(S, closed, stop, false, false, true, empty) -> BUSY(S, closed, stop, false, false, true, empty) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (93) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 27 less nodes. ---------------------------------------- (94) TRUE