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

Termination of R to be shown. 



   R
     ↳Removing Redundant Rules



Removing the following rules from R which fullfill a polynomial ordering:

start(i) -> busy(F, closed, stop, false, false, false, i)

where the Polynomial interpretation:
  POL(open)=  0  
  POL(busy(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(FS)=  0  
  POL(false)=  0  
  POL(stop)=  0  
  POL(closed)=  0  
  POL(up)=  0  
  POL(or(x1, x2))=  x1 + x2  
  POL(true)=  0  
  POL(correct)=  0  
  POL(newbuttons(x1, x2, x3, x4))=  x1 + x2 + x3 + x4  
  POL(down)=  0  
  POL(F)=  0  
  POL(start(x1))=  1 + x1  
  POL(incorrect)=  0  
  POL(B)=  0  
  POL(BF)=  0  
  POL(S)=  0  
  POL(empty)=  0  
  POL(idle(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
was used.

Not all Rules of R can be deleted, so we still have to regard a part of R. 


   R
     ↳RRRPolo
       →TRS2
         ↳Overlay and local confluence Check



The TRS is overlay and locally confluent (all critical pairs are trivially joinable).Hence, we can switch to innermost. 


   R
     ↳RRRPolo
       →TRS2
         ↳OC
           →TRS3
             ↳Dependency Pair Analysis



R contains the following Dependency Pairs:

BUSY(S, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)
BUSY(F, closed, stop, false, false, true, i) -> IDLE(F, closed, up, false, false, true, i)
BUSY(F, closed, down, b1, false, b3, i) -> IDLE(BF, closed, down, b1, false, b3, i)
BUSY(F, closed, down, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, 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(F, closed, up, b1, false, b3, i) -> IDLE(FS, closed, up, b1, false, b3, i)
BUSY(S, closed, down, b1, b2, false, i) -> IDLE(FS, closed, down, b1, b2, false, i)
BUSY(S, closed, stop, true, false, false, i) -> IDLE(S, closed, down, true, false, false, i)
BUSY(BF, closed, down, b1, b2, b3, i) -> IDLE(B, closed, down, 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(B, open, stop, false, b2, b3, i) -> IDLE(B, closed, stop, false, b2, b3, i)
BUSY(F, closed, up, b1, true, b3, i) -> IDLE(F, closed, stop, b1, true, b3, i)
BUSY(B, closed, stop, false, true, b3, i) -> IDLE(B, closed, up, false, true, b3, i)
BUSY(F, open, stop, b1, false, b3, i) -> IDLE(F, closed, stop, b1, false, b3, i)
BUSY(B, closed, up, false, b2, b3, i) -> IDLE(BF, closed, up, false, b2, b3, i)
BUSY(B, d, stop, true, b2, b3, i) -> IDLE(B, open, stop, false, b2, b3, 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(FS, closed, down, b1, b2, b3, i) -> IDLE(F, closed, down, b1, b2, b3, i)
BUSY(S, closed, down, b1, b2, true, i) -> IDLE(S, closed, stop, b1, b2, true, i)
BUSY(B, closed, down, b1, b2, b3, i) -> IDLE(B, closed, stop, b1, b2, b3, i)
BUSY(BF, closed, up, b1, b2, b3, i) -> IDLE(F, closed, up, b1, b2, b3, 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, open, stop, b1, b2, false, i) -> IDLE(S, closed, stop, b1, b2, false, i)
BUSY(B, closed, stop, false, false, true, i) -> IDLE(B, closed, up, false, false, true, i)
BUSY(F, d, stop, b1, true, b3, i) -> IDLE(F, open, stop, b1, false, b3, i)
BUSY(F, closed, stop, true, false, b3, i) -> IDLE(F, closed, down, true, false, b3, i)
BUSY(S, closed, stop, b1, true, false, i) -> IDLE(S, closed, down, b1, true, false, 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)
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
     ↳RRRPolo
       →TRS2
         ↳OC
           →TRS3
             ↳DPs
             ...
               →DP Problem 1
                 ↳Usable Rules (Innermost)


Dependency Pairs:

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


Rules:


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




As we are in the innermost case, we can delete all 38 non-usable-rules.


   R
     ↳RRRPolo
       →TRS2
         ↳OC
           →TRS3
             ↳DPs
             ...
               →DP Problem 2
                 ↳Modular Removal of Rules


Dependency Pairs:

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


Rules:


or(false, b) -> b
or(true, b) -> true


Strategy:

innermost




We have the following set of usable rules:

or(false, b) -> b
or(true, b) -> true
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(open)=  0  
  POL(BUSY(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(FS)=  0  
  POL(false)=  0  
  POL(closed)=  0  
  POL(stop)=  0  
  POL(IDLE(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(up)=  0  
  POL(or(x1, x2))=  x1 + x2  
  POL(true)=  1  
  POL(newbuttons(x1, x2, x3, x4))=  x1 + x2 + x3 + x4  
  POL(down)=  0  
  POL(F)=  0  
  POL(B)=  0  
  POL(BF)=  0  
  POL(S)=  0  
  POL(empty)=  0  

We have the following set D of usable symbols: {open, BUSY, FS, false, closed, stop, IDLE, up, true, or, down, newbuttons, F, B, BF, S, empty}
The following Dependency Pairs can be deleted as the lhs is strictly greater than the corresponding rhs:

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, d, stop, b1, b2, true, i) -> IDLE(S, open, stop, b1, b2, false, i)

No Rules can be deleted.

The result of this processor delivers one new DP problem.



   R
     ↳RRRPolo
       →TRS2
         ↳OC
           →TRS3
             ↳DPs
             ...
               →DP Problem 3
                 ↳Modular Removal of Rules


Dependency Pairs:

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


Rules:


or(false, b) -> b
or(true, b) -> true


Strategy:

innermost




We have the following set of usable rules:

or(false, b) -> b
or(true, b) -> true
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(open)=  0  
  POL(BUSY(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(FS)=  0  
  POL(false)=  0  
  POL(closed)=  0  
  POL(stop)=  0  
  POL(IDLE(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(up)=  0  
  POL(or(x1, x2))=  x1 + x2  
  POL(true)=  0  
  POL(newbuttons(x1, x2, x3, x4))=  x1 + x2 + x3 + x4  
  POL(down)=  0  
  POL(F)=  0  
  POL(B)=  0  
  POL(BF)=  0  
  POL(S)=  0  
  POL(empty)=  0  

We have the following set D of usable symbols: {BUSY, FS, false, closed, stop, IDLE, up, true, or, down, newbuttons, F, B, BF, S, empty}
The following Dependency Pairs can be deleted as they contain symbols in their lhs which do not occur in D:

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)

No Rules can be deleted.

The result of this processor delivers one new DP problem.



   R
     ↳RRRPolo
       →TRS2
         ↳OC
           →TRS3
             ↳DPs
             ...
               →DP Problem 4
                 ↳Modular Removal of Rules


Dependency Pairs:

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


Rules:


or(false, b) -> b
or(true, b) -> true


Strategy:

innermost




We have the following set of usable rules:

or(false, b) -> b
or(true, b) -> true
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(BUSY(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(FS)=  0  
  POL(false)=  0  
  POL(closed)=  0  
  POL(stop)=  0  
  POL(IDLE(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(up)=  0  
  POL(or(x1, x2))=  x1 + x2  
  POL(true)=  0  
  POL(down)=  0  
  POL(newbuttons(x1, x2, x3, x4))=  1 + x1 + x2 + x3 + x4  
  POL(F)=  0  
  POL(B)=  0  
  POL(BF)=  0  
  POL(S)=  0  
  POL(empty)=  0  

We have the following set D of usable symbols: {BUSY, FS, false, closed, stop, IDLE, up, true, or, down, newbuttons, F, B, BF, S, empty}
The following Dependency Pairs can be deleted as the lhs is strictly greater than the corresponding rhs:

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)

No Rules can be deleted.

The result of this processor delivers one new DP problem.



   R
     ↳RRRPolo
       →TRS2
         ↳OC
           →TRS3
             ↳DPs
             ...
               →DP Problem 5
                 ↳Modular Removal of Rules


Dependency Pairs:

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


Rules:


or(false, b) -> b
or(true, b) -> true


Strategy:

innermost




We have the following set of usable rules: none
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(BUSY(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(FS)=  0  
  POL(false)=  0  
  POL(closed)=  0  
  POL(stop)=  0  
  POL(IDLE(x1, x2, x3, x4, x5, x6, x7))=  x1 + x2 + x3 + x4 + x5 + x6 + x7  
  POL(up)=  0  
  POL(true)=  0  
  POL(down)=  0  
  POL(newbuttons(x1, x2, x3, x4))=  x1 + x2 + x3 + x4  
  POL(F)=  0  
  POL(B)=  0  
  POL(BF)=  0  
  POL(S)=  0  
  POL(empty)=  0  

We have the following set D of usable symbols: {BUSY, FS, false, closed, stop, IDLE, up, true, down, newbuttons, F, B, BF, S, empty}
No Dependency Pairs can be deleted.
2 non usable rules have been deleted.

The result of this processor delivers one new DP problem.



   R
     ↳RRRPolo
       →TRS2
         ↳OC
           →TRS3
             ↳DPs
             ...
               →DP Problem 6
                 ↳Dependency Graph


Dependency Pairs:

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


Rule:

none


Strategy:

innermost




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


   R
     ↳RRRPolo
       →TRS2
         ↳OC
           →TRS3
             ↳DPs
             ...
               →DP Problem 7
                 ↳Remaining Obligation(s)




The following remains to be proven:
Dependency Pairs:

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


Rule:

none


Strategy:

innermost



The Proof could not be continued due to a Timeout.
Termination of R could not be shown.
Duration:
1:00 minutes