Term Rewriting System R:
[i, d, b1, b2, b3, fl, i1, i2, i3, m, b]
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

Innermost Termination of R to be shown. 



   R
     ↳Dependency Pair Analysis



R contains the following Dependency Pairs:

START(i) -> BUSY(F, closed, stop, false, false, false, i)
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)
IDLE(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> OR(b1, i1)
IDLE(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> OR(b2, i2)
IDLE(fl, d, m, b1, b2, b3, newbuttons(i1, i2, i3, i)) -> OR(b3, i3)

Furthermore, R contains one SCC. 


   R
     ↳DPs
       →DP Problem 1
         ↳Argument Filtering and Ordering


Dependency Pairs:

BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
BUSY(B, d, stop, true, b2, b3, i) -> IDLE(B, open, stop, false, b2, b3, i)
BUSY(S, open, stop, b1, b2, false, i) -> IDLE(S, closed, stop, b1, b2, false, i)
BUSY(F, open, stop, b1, false, b3, i) -> IDLE(F, closed, stop, b1, false, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, open, stop, false, b2, b3, i) -> IDLE(B, closed, stop, false, b2, b3, 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, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> IDLE(B, closed, stop, false, false, false, newbuttons(i1, i2, i3, i))
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)
BUSY(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i)) -> IDLE(F, closed, stop, false, false, false, newbuttons(i1, i2, i3, i))


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


Strategy:

innermost




The following dependency pair can be strictly oriented:

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)


There are no usable rules for innermost w.r.t. to the AFS that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
BUSY(x1, x2, x3, x4, x5, x6, x7) -> x7
IDLE(x1, x2, x3, x4, x5, x6, x7) -> x7
newbuttons(x1, x2, x3, x4) -> newbuttons(x1, x2, x3, x4)


   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳Dependency Graph


Dependency Pairs:

BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
BUSY(B, d, stop, true, b2, b3, i) -> IDLE(B, open, stop, false, b2, b3, i)
BUSY(S, open, stop, b1, b2, false, i) -> IDLE(S, closed, stop, b1, b2, false, i)
BUSY(F, open, stop, b1, false, b3, i) -> IDLE(F, closed, stop, b1, false, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, open, stop, false, b2, b3, i) -> IDLE(B, closed, stop, false, b2, b3, 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, 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))


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


Strategy:

innermost




Using the Dependency Graph the DP problem was split into 1 DP problems.


   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 3
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
BUSY(B, d, stop, true, b2, b3, i) -> IDLE(B, open, stop, false, b2, b3, i)
BUSY(S, open, stop, b1, b2, false, i) -> IDLE(S, closed, stop, b1, b2, false, i)
BUSY(F, open, stop, b1, false, b3, i) -> IDLE(F, closed, stop, b1, false, b3, i)
BUSY(B, open, stop, false, b2, b3, i) -> IDLE(B, closed, stop, false, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(B, open, stop, false, b2, b3, i) -> IDLE(B, closed, stop, false, b2, b3, i)
one new Dependency Pair is created:

BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 4
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
BUSY(B, d, stop, true, b2, b3, i) -> IDLE(B, open, stop, false, b2, b3, i)
BUSY(S, open, stop, b1, b2, false, i) -> IDLE(S, closed, stop, b1, b2, false, i)
BUSY(F, open, stop, b1, false, b3, i) -> IDLE(F, closed, stop, b1, false, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(F, open, stop, b1, false, b3, i) -> IDLE(F, closed, stop, b1, false, b3, i)
one new Dependency Pair is created:

BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 5
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
BUSY(B, d, stop, true, b2, b3, i) -> IDLE(B, open, stop, false, b2, b3, i)
BUSY(S, open, stop, b1, b2, false, i) -> IDLE(S, closed, stop, b1, b2, false, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(S, open, stop, b1, b2, false, i) -> IDLE(S, closed, stop, b1, b2, false, i)
one new Dependency Pair is created:

BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 6
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
BUSY(B, d, stop, true, b2, b3, i) -> IDLE(B, open, stop, false, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(B, d, stop, true, b2, b3, i) -> IDLE(B, open, stop, false, b2, b3, i)
one new Dependency Pair is created:

BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 7
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
one new Dependency Pair is created:

BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 8
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
one new Dependency Pair is created:

BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 9
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
one new Dependency Pair is created:

BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 10
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(S, closed, up, b1, b2, b3, i) -> IDLE(S, closed, stop, b1, b2, b3, i)
one new Dependency Pair is created:

BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 11
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(B, closed, up, true, b2, b3, i) -> IDLE(B, closed, stop, true, b2, b3, i)
one new Dependency Pair is created:

BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 12
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
one new Dependency Pair is created:

BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 13
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
one new Dependency Pair is created:

BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 14
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
one new Dependency Pair is created:

BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 15
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
one new Dependency Pair is created:

BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 16
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
one new Dependency Pair is created:

BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 17
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
one new Dependency Pair is created:

BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 18
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
one new Dependency Pair is created:

BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 19
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, i)
one new Dependency Pair is created:

BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 20
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, b1, b2, b3, i)
one new Dependency Pair is created:

BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 21
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(FS, closed, up, b1, b2, b3, i) -> IDLE(S, closed, up, b1, b2, b3, i)
one new Dependency Pair is created:

BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 22
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
one new Dependency Pair is created:

BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 23
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
one new Dependency Pair is created:

BUSY(B, closed, stop, false, true, b3'', empty) -> IDLE(B, closed, up, false, true, b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 24
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(B, closed, stop, false, true, b3'', empty) -> IDLE(B, closed, up, false, true, b3'', empty)
BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
one new Dependency Pair is created:

BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 25
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty)
BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)
BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, closed, stop, false, true, b3'', empty) -> IDLE(B, closed, up, false, true, b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
one new Dependency Pair is created:

BUSY(F, closed, stop, true, false, b3'', empty) -> IDLE(F, closed, down, true, false, b3'', empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 26
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(F, closed, stop, true, false, b3'', empty) -> IDLE(F, closed, down, true, false, b3'', empty)
BUSY(B, closed, stop, false, true, b3'', empty) -> IDLE(B, closed, up, false, true, b3'', empty)
BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)
BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
one new Dependency Pair is created:

BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 27
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty)
BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty)
BUSY(B, closed, stop, false, true, b3'', empty) -> IDLE(B, closed, up, false, true, b3'', empty)
BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)
BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(F, closed, stop, true, false, b3'', empty) -> IDLE(F, closed, down, true, false, b3'', empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, i)
one new Dependency Pair is created:

BUSY(S, closed, stop, b1'', true, false, empty) -> IDLE(S, closed, down, b1'', true, false, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 28
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(S, closed, stop, b1'', true, false, empty) -> IDLE(S, closed, down, b1'', true, false, empty)
BUSY(F, closed, stop, true, false, b3'', empty) -> IDLE(F, closed, down, true, false, b3'', empty)
BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty)
BUSY(B, closed, stop, false, true, b3'', empty) -> IDLE(B, closed, up, false, true, b3'', empty)
BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)
BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
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(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
one new Dependency Pair is created:

BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 29
                 ↳Instantiation Transformation


Dependency Pairs:

BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty)
BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty)
BUSY(F, closed, stop, true, false, b3'', empty) -> IDLE(F, closed, down, true, false, b3'', empty)
BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, closed, up, false, false, true, empty)
BUSY(B, closed, stop, false, true, b3'', empty) -> IDLE(B, closed, up, false, true, b3'', empty)
BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)
BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
BUSY(S, closed, down, b1'', b2'', true, empty) -> IDLE(S, closed, stop, b1'', b2'', true, empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
BUSY(B, closed, up, true, b2'', b3'', empty) -> IDLE(B, closed, stop, true, b2'', b3'', empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
BUSY(S, closed, stop, b1'', true, false, empty) -> IDLE(S, closed, down, b1'', true, false, empty)


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


Strategy:

innermost




On this DP problem, an Instantiation SCC transformation can be performed.
As a result of transforming the rule

IDLE(fl, d, m, b1, b2, b3, empty) -> BUSY(fl, d, m, b1, b2, b3, empty)
25 new Dependency Pairs are created:

IDLE(B, closed, stop, false, b2', b3', empty) -> BUSY(B, closed, stop, false, b2', b3', empty)
IDLE(F, closed, stop, b1', false, b3', empty) -> BUSY(F, closed, stop, b1', false, b3', empty)
IDLE(S, closed, stop, b1', b2', false, empty) -> BUSY(S, closed, stop, b1', b2', false, empty)
IDLE(B, open, stop, false, b2', b3', empty) -> BUSY(B, open, stop, false, b2', b3', empty)
IDLE(F, open, stop, b1', false, b3', empty) -> BUSY(F, open, stop, b1', false, b3', empty)
IDLE(S, open, stop, b1', b2', false, empty) -> BUSY(S, open, stop, b1', b2', false, empty)
IDLE(B, closed, stop, b1', b2', b3', empty) -> BUSY(B, closed, stop, b1', b2', b3', empty)
IDLE(S, closed, stop, b1', b2', b3', empty) -> BUSY(S, closed, stop, b1', b2', b3', empty)
IDLE(B, closed, stop, true, b2', b3', empty) -> BUSY(B, closed, stop, true, b2', b3', empty)
IDLE(F, closed, stop, b1', true, b3', empty) -> BUSY(F, closed, stop, b1', true, b3', empty)
IDLE(S, closed, stop, b1', b2', true, empty) -> BUSY(S, closed, stop, b1', b2', true, empty)
IDLE(BF, closed, up, false, b2', b3', empty) -> BUSY(BF, closed, up, false, b2', b3', empty)
IDLE(FS, closed, up, b1', false, b3', empty) -> BUSY(FS, closed, up, b1', false, b3', empty)
IDLE(BF, closed, down, b1', false, b3', empty) -> BUSY(BF, closed, down, b1', false, b3', empty)
IDLE(FS, closed, down, b1', b2', false, empty) -> BUSY(FS, closed, down, b1', b2', false, empty)
IDLE(F, closed, up, b1', b2', b3', empty) -> BUSY(F, closed, up, b1', b2', b3', empty)
IDLE(B, closed, down, b1', b2', b3', empty) -> BUSY(B, closed, down, b1', b2', b3', empty)
IDLE(S, closed, up, b1', b2', b3', empty) -> BUSY(S, closed, up, b1', b2', b3', empty)
IDLE(F, closed, down, b1', b2', b3', empty) -> BUSY(F, closed, down, b1', b2', b3', empty)
IDLE(B, closed, up, false, true, b3', empty) -> BUSY(B, closed, up, false, true, b3', empty)
IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty)
IDLE(F, closed, down, true, false, b3', empty) -> BUSY(F, closed, down, true, false, b3', empty)
IDLE(F, closed, up, false, false, true, empty) -> BUSY(F, closed, up, false, false, true, empty)
IDLE(S, closed, down, b1', true, false, empty) -> BUSY(S, closed, down, b1', true, false, empty)
IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳AFS
           →DP Problem 2
             ↳DGraph
             ...
               →DP Problem 30
                 ↳Remaining Obligation(s)




The following remains to be proven:
Dependency Pairs:

BUSY(F, closed, stop, false, false, true, empty) -> IDLE(F, closed, up, false, false, true, empty)
IDLE(B, closed, stop, true, b2', b3', empty) -> BUSY(B, closed, stop, true, b2', b3', empty)
BUSY(B, open, stop, false, b2'', b3'', empty) -> IDLE(B, closed, stop, false, b2'', b3'', empty)
IDLE(B, open, stop, false, b2', b3', empty) -> BUSY(B, open, stop, false, b2', b3', empty)
BUSY(B, d'', stop, true, b2'', b3'', empty) -> IDLE(B, open, stop, false, b2'', b3'', empty)
IDLE(B, closed, stop, b1', b2', b3', empty) -> BUSY(B, closed, stop, b1', b2', b3', empty)
IDLE(B, closed, up, false, false, true, empty) -> BUSY(B, closed, up, false, false, true, empty)
BUSY(B, closed, stop, false, false, true, empty) -> IDLE(B, 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, b1', b2', true, empty) -> BUSY(S, closed, stop, b1', b2', true, empty)
BUSY(S, open, stop, b1'', b2'', false, empty) -> IDLE(S, closed, stop, b1'', b2'', false, empty)
IDLE(S, open, stop, b1', b2', false, empty) -> BUSY(S, open, stop, b1', b2', false, empty)
BUSY(S, d'', stop, b1'', b2'', true, empty) -> IDLE(S, open, stop, b1'', b2'', false, empty)
IDLE(S, closed, stop, b1', b2', b3', empty) -> BUSY(S, closed, stop, b1', b2', b3', empty)
IDLE(S, closed, down, b1', true, false, empty) -> BUSY(S, closed, down, b1', true, false, empty)
BUSY(S, closed, stop, b1'', true, false, empty) -> IDLE(S, closed, down, b1'', true, false, empty)
IDLE(S, closed, stop, b1', b2', false, empty) -> BUSY(S, closed, stop, b1', b2', false, empty)
BUSY(S, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, stop, b1'', b2'', b3'', empty)
IDLE(S, closed, up, b1', b2', b3', empty) -> BUSY(S, closed, up, b1', b2', b3', empty)
BUSY(FS, closed, up, b1'', b2'', b3'', empty) -> IDLE(S, closed, up, b1'', b2'', b3'', empty)
IDLE(FS, closed, up, b1', false, b3', empty) -> BUSY(FS, closed, up, b1', false, b3', empty)
BUSY(F, closed, up, b1'', false, b3'', empty) -> IDLE(FS, closed, up, b1'', false, b3'', empty)
BUSY(F, closed, up, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
IDLE(F, closed, up, b1', b2', b3', empty) -> BUSY(F, closed, up, b1', b2', b3', empty)
BUSY(BF, closed, up, b1'', b2'', b3'', empty) -> IDLE(F, closed, up, b1'', b2'', b3'', empty)
IDLE(BF, closed, up, false, b2', b3', empty) -> BUSY(BF, closed, up, false, b2', b3', empty)
BUSY(B, closed, up, false, b2'', b3'', empty) -> IDLE(BF, closed, up, false, b2'', b3'', empty)
IDLE(B, closed, up, false, true, b3', empty) -> BUSY(B, closed, up, false, true, b3', empty)
BUSY(B, closed, stop, false, true, b3'', empty) -> IDLE(B, closed, up, false, true, b3'', empty)
IDLE(B, closed, stop, false, b2', b3', empty) -> BUSY(B, closed, stop, false, b2', b3', empty)
BUSY(B, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, stop, b1'', b2'', b3'', empty)
IDLE(B, closed, down, b1', b2', b3', empty) -> BUSY(B, closed, down, b1', b2', b3', empty)
BUSY(BF, closed, down, b1'', b2'', b3'', empty) -> IDLE(B, closed, down, b1'', b2'', b3'', empty)
IDLE(BF, closed, down, b1', false, b3', empty) -> BUSY(BF, closed, down, b1', false, b3', empty)
BUSY(F, closed, down, b1'', false, b3'', empty) -> IDLE(BF, closed, down, b1'', false, b3'', empty)
IDLE(F, closed, down, true, false, b3', empty) -> BUSY(F, closed, down, true, false, b3', empty)
BUSY(F, closed, stop, true, false, b3'', empty) -> IDLE(F, closed, down, true, false, b3'', empty)
IDLE(F, closed, stop, b1', false, b3', empty) -> BUSY(F, closed, stop, b1', false, b3', empty)
BUSY(F, open, stop, b1'', false, b3'', empty) -> IDLE(F, closed, stop, b1'', false, b3'', empty)
IDLE(F, open, stop, b1', false, b3', empty) -> BUSY(F, open, stop, b1', false, b3', empty)
BUSY(F, d'', stop, b1'', true, b3'', empty) -> IDLE(F, open, stop, b1'', false, b3'', empty)
IDLE(F, closed, stop, b1', true, b3', empty) -> BUSY(F, closed, stop, b1', true, b3', empty)
BUSY(F, closed, down, b1'', true, b3'', empty) -> IDLE(F, closed, stop, b1'', true, b3'', empty)
IDLE(F, closed, down, b1', b2', b3', empty) -> BUSY(F, closed, down, b1', b2', b3', empty)
BUSY(FS, closed, down, b1'', b2'', b3'', empty) -> IDLE(F, closed, down, b1'', b2'', b3'', empty)
IDLE(FS, closed, down, b1', b2', false, empty) -> BUSY(FS, closed, down, b1', b2', false, empty)
BUSY(S, closed, down, b1'', b2'', false, empty) -> IDLE(FS, closed, down, b1'', b2'', false, empty)
IDLE(S, closed, down, true, false, false, empty) -> BUSY(S, closed, down, true, false, false, empty)
BUSY(S, closed, stop, true, false, false, empty) -> IDLE(S, closed, down, true, false, false, empty)


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


Strategy:

innermost



Innermost Termination of R could not be shown.
Duration:
0:17 minutes