YES

We show the termination of the TRS R:

  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

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: start#(i) -> busy#(F(),closed(),stop(),false(),false(),false(),i)
p2: busy#(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle#(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
p3: busy#(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle#(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
p4: busy#(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle#(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
p5: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p6: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p7: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p8: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p9: busy#(F(),d,stop(),b1,true(),b3,i) -> idle#(F(),open(),stop(),b1,false(),b3,i)
p10: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p11: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p12: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p13: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p14: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p15: busy#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p16: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p17: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p18: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p19: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p20: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p21: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p22: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p23: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p24: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p25: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p26: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p27: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p28: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p29: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p30: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p31: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p32: 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)
p33: idle#(fl,d,m,b1,b2,b3,newbuttons(i1,i2,i3,i)) -> or#(b1,i1)
p34: idle#(fl,d,m,b1,b2,b3,newbuttons(i1,i2,i3,i)) -> or#(b2,i2)
p35: idle#(fl,d,m,b1,b2,b3,newbuttons(i1,i2,i3,i)) -> or#(b3,i3)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle#(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
p2: 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)
p3: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p4: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p5: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p6: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p7: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p8: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p9: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p10: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p11: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p12: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p13: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p14: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p15: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p16: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p17: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p18: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p19: busy#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p20: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p21: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p22: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p23: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p24: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p25: busy#(F(),d,stop(),b1,true(),b3,i) -> idle#(F(),open(),stop(),b1,false(),b3,i)
p26: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p27: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p28: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p29: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p30: busy#(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle#(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
p31: busy#(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle#(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  r40, r41

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x2 + 1, x3 + 1, x4 + 1, x5 + 1, x6 + 7, x7 + 1}
    F_A = 6
    closed_A = 3
    stop_A = 0
    false_A = 0
    newbuttons_A(x1,x2,x3,x4) = max{x1 + 14, x2 + 14, x3 + 18, x4 + 14}
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x2 + 1, x3 + 1, x4 + 1, x5 + 1, x6 + 7, x7 - 6}
    or_A(x1,x2) = max{x1, x2 + 5}
    S_A = 0
    true_A = 6
    down_A = 0
    empty_A = 0
    up_A = 1
    B_A = 6
    FS_A = 5
    BF_A = 2
    open_A = 6

The next rules are strictly ordered:

  p1, p30, p31

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: 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)
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p4: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p5: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p6: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p7: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p8: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p9: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p12: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p13: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p14: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p15: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p16: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p17: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p18: busy#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p19: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p20: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p21: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p22: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p23: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p24: busy#(F(),d,stop(),b1,true(),b3,i) -> idle#(F(),open(),stop(),b1,false(),b3,i)
p25: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p26: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p27: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p28: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: 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)
p2: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p3: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p4: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p5: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p6: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p7: busy#(F(),d,stop(),b1,true(),b3,i) -> idle#(F(),open(),stop(),b1,false(),b3,i)
p8: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p9: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p10: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p11: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p12: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p13: busy#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p14: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p15: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p16: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p17: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p18: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p19: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p20: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p21: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p22: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p23: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p24: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p25: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p26: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p27: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p28: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  r40, r41

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 + 10, x3 + 1, x4 + 1, x5 - 2, x6 - 2, x7 + 11}
    newbuttons_A(x1,x2,x3,x4) = max{x1 + 5, x2 + 5, x3 + 5, x4 + 5}
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{15, x2 + 9, x3 - 3, x4 + 1, x5 - 2, x6 - 2, x7 + 11}
    or_A(x1,x2) = max{4, x2}
    B_A = 14
    open_A = 2
    stop_A = 14
    false_A = 7
    closed_A = 0
    empty_A = 5
    F_A = 0
    S_A = 6
    true_A = 4
    down_A = 14
    up_A = 14
    BF_A = 15
    FS_A = 16

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p4: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p5: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p6: busy#(F(),d,stop(),b1,true(),b3,i) -> idle#(F(),open(),stop(),b1,false(),b3,i)
p7: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p8: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p9: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p10: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p11: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p12: busy#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p13: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p14: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p15: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p16: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p17: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p18: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p19: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p20: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p21: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p22: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p23: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p24: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p25: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p26: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p27: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p4: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p5: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p6: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p7: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p8: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p9: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p12: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p13: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p14: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p15: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p16: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p17: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p18: busy#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p19: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p20: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p21: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p22: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p23: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p24: busy#(F(),d,stop(),b1,true(),b3,i) -> idle#(F(),open(),stop(),b1,false(),b3,i)
p25: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p26: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p27: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 8, x2 - 4, x3 - 17, x5 + 15, x7 + 10}
    B_A = 13
    open_A = 1
    stop_A = 0
    false_A = 2
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 8, x2 - 4, x3 - 6, x5 + 15, x7 - 1}
    closed_A = 3
    empty_A = 0
    S_A = 5
    true_A = 13
    down_A = 21
    F_A = 11
    up_A = 17
    FS_A = 0
    BF_A = 10

The next rules are strictly ordered:

  p24

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p4: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p5: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p6: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p7: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p8: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p9: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p12: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p13: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p14: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p15: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p16: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p17: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p18: busy#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p19: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p20: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p21: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p22: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p23: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p24: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p25: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p26: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p4: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p5: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p6: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p7: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p8: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p9: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p10: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p11: busy#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p12: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p13: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p14: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p15: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p16: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p17: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p18: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p19: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p20: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p21: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p22: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p23: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p24: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p25: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p26: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x3, x5 + 12, x7 + 1}
    B_A = 1
    open_A = 6
    stop_A = 3
    false_A = 4
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x2 + 5, x3, x5 + 12, x7}
    closed_A = 0
    empty_A = 0
    F_A = 10
    S_A = 15
    true_A = 2
    down_A = 15
    up_A = 13
    BF_A = 0
    FS_A = 15

The next rules are strictly ordered:

  p11

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p4: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p5: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p6: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p7: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p8: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p9: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p10: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p11: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p12: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p13: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p14: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p15: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p16: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p17: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p18: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p19: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p20: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p21: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p22: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p23: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p24: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p25: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p4: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p5: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p6: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p7: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p8: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p9: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p12: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p13: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p14: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p15: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p16: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p17: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p18: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p19: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p20: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p21: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p22: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p23: busy#(B(),d,stop(),true(),b2,b3,i) -> idle#(B(),open(),stop(),false(),b2,b3,i)
p24: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p25: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1, x2 + 1, x3 + 8, x4 + 1, x7 + 1}
    B_A = 10
    open_A = 9
    stop_A = 2
    false_A = 4
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1, x2 + 1, x3 + 8, x4 + 1, x7}
    closed_A = 5
    empty_A = 0
    S_A = 10
    true_A = 14
    down_A = 2
    F_A = 10
    up_A = 1
    FS_A = 10
    BF_A = 10

The next rules are strictly ordered:

  p23

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p4: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p5: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p6: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p7: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p8: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p9: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p12: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p13: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p14: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p15: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p16: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p17: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p18: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p19: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p20: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p21: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p22: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p23: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p24: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p4: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p5: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p6: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p7: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p8: busy#(B(),closed(),up(),true(),b2,b3,i) -> idle#(B(),closed(),stop(),true(),b2,b3,i)
p9: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p10: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p11: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p12: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p13: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p14: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p15: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p16: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p17: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p18: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p19: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p20: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p21: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p22: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p23: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p24: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 8, x3 + 30, x4 + 15, x7 + 13}
    B_A = 2
    open_A = 31
    stop_A = 0
    false_A = 23
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 8, x2 - 21, x3 + 31, x4 + 15, x7 + 12}
    closed_A = 35
    empty_A = 0
    F_A = 30
    S_A = 30
    true_A = 8
    down_A = 6
    up_A = 2
    BF_A = 30
    FS_A = 30

The next rules are strictly ordered:

  p8

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p4: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p5: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p6: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p7: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p8: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p9: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p10: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p11: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p12: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p13: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p14: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p15: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p16: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p17: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p18: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p19: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p20: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p21: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p22: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p23: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p4: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p5: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p6: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p7: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p8: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p9: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p12: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p13: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p14: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p15: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p16: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p17: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p18: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p19: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p20: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p21: busy#(S(),d,stop(),b1,b2,true(),i) -> idle#(S(),open(),stop(),b1,b2,false(),i)
p22: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p23: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x6 + 77, x7 + 65}
    B_A = 62
    open_A = 6
    stop_A = 74
    false_A = 72
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 4, x2 + 62, x3 + 2, x6 + 77, x7 + 64}
    closed_A = 14
    empty_A = 0
    S_A = 60
    true_A = 78
    down_A = 30
    F_A = 0
    up_A = 0
    FS_A = 46
    BF_A = 14

The next rules are strictly ordered:

  p21

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p4: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p5: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p6: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p7: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p8: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p9: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p12: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p13: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p14: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p15: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p16: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p17: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p18: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p19: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p20: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p21: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p22: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: busy#(B(),open(),stop(),false(),b2,b3,i) -> idle#(B(),closed(),stop(),false(),b2,b3,i)
p2: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p3: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p4: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p5: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p6: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p7: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p8: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p9: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p10: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p11: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p12: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p13: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p14: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p15: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p16: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p17: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p18: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p19: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p20: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p21: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p22: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 - 2, x3 + 6, x4 - 2, x7}
    B_A = 4
    open_A = 13
    stop_A = 0
    false_A = 12
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 - 1, x3 + 6, x4 - 2, x7 - 1}
    closed_A = 3
    empty_A = 0
    F_A = 9
    S_A = 10
    down_A = 1
    up_A = 3
    true_A = 1
    BF_A = 5
    FS_A = 9

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p3: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p4: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p5: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p6: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p7: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p8: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p9: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p10: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p11: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p12: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p13: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p14: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p15: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p16: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p17: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p18: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p19: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p20: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p21: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p4: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p5: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p6: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p7: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p8: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p9: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p10: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p11: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p12: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p13: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p14: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p15: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p16: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p17: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p18: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p19: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p20: busy#(S(),open(),stop(),b1,b2,false(),i) -> idle#(S(),closed(),stop(),b1,b2,false(),i)
p21: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 16, x2 + 14, x6 + 1}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 16, x2 + 13, x6 + 1}
    S_A = 1
    closed_A = 0
    stop_A = 13
    true_A = 9
    false_A = 2
    down_A = 5
    F_A = 1
    up_A = 13
    B_A = 1
    FS_A = 1
    BF_A = 1
    open_A = 15

The next rules are strictly ordered:

  p20

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p4: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p5: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p6: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p7: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p8: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p9: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p10: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p11: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p12: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p13: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p14: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p15: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p16: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p17: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p18: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p19: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p20: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(F(),open(),stop(),b1,false(),b3,i) -> idle#(F(),closed(),stop(),b1,false(),b3,i)
p3: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p4: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p5: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p6: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p7: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p8: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p9: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p10: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p11: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p12: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p13: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p14: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p15: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p16: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p17: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p18: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p19: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p20: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 10, x2 - 1, x3, x5 - 1, x7 - 3}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x1 - 11, x2 - 1, x3 - 6, x5 - 1, x7 - 2}
    F_A = 4
    open_A = 2
    stop_A = 0
    false_A = 0
    closed_A = 0
    B_A = 5
    down_A = 0
    S_A = 0
    up_A = 0
    true_A = 3
    BF_A = 7
    FS_A = 2

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p5: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p6: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p7: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p8: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p9: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p10: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p11: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p12: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p13: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p14: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p15: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p16: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p17: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p18: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p19: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p4: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p5: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p6: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p7: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p8: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p9: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p10: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p11: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p12: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p13: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p14: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p15: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p16: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p17: busy#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p18: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p19: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x1 - 1, x2 - 3, x3 - 4, x5 - 24}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x1 - 1, x2 - 3, x3 - 10, x5 - 24}
    S_A = 12
    closed_A = 0
    stop_A = 5
    true_A = 18
    false_A = 36
    down_A = 0
    F_A = 4
    up_A = 14
    B_A = 12
    FS_A = 12
    BF_A = 12

The next rules are strictly ordered:

  p17

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p4: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p5: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p6: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p7: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p8: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p9: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p10: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p11: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p12: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p13: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p14: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p15: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p16: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p17: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p18: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(S(),closed(),down(),b1,b2,true(),i) -> idle#(S(),closed(),stop(),b1,b2,true(),i)
p5: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p6: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p7: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p8: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p9: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p10: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p11: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p12: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p13: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p14: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p15: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p16: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p17: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p18: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 24, x2 - 2, x3 + 22, x6 + 26, x7 + 20}
    empty_A = 4
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 24, x3 + 14, x6 + 26, x7 + 21}
    B_A = 15
    closed_A = 0
    down_A = 16
    stop_A = 0
    S_A = 5
    up_A = 7
    true_A = 2
    false_A = 13
    BF_A = 15
    F_A = 15
    FS_A = 15

The next rules are strictly ordered:

  p4

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p5: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p6: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p7: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p8: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p9: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p12: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p13: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p14: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p15: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p16: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p17: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(S(),closed(),stop(),b1,true(),false(),i) -> idle#(S(),closed(),down(),b1,true(),false(),i)
p4: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p5: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p6: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p7: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p8: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p9: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p10: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p11: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p12: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p13: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p14: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p15: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p16: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p17: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 8, x2 + 6, x3 + 25, x5 + 10, x7 + 6}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 8, x2 + 6, x3 + 25, x5 + 10, x7 + 7}
    S_A = 0
    closed_A = 0
    stop_A = 1
    true_A = 6
    false_A = 19
    down_A = 0
    F_A = 17
    up_A = 2
    B_A = 20
    FS_A = 1
    BF_A = 20

The next rules are strictly ordered:

  p3

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p4: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p5: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p6: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p7: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p8: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p9: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p10: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p11: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p12: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p13: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p14: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p15: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p16: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p5: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p6: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p7: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p8: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p9: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p10: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p11: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p12: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p13: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p14: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p15: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p16: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 13, x2 + 24, x3 + 28, x4 + 14, x7 + 26}
    empty_A = 1
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 13, x2 + 23, x3 + 28, x4 + 14, x7 + 27}
    B_A = 17
    closed_A = 0
    down_A = 3
    stop_A = 0
    S_A = 13
    up_A = 1
    false_A = 8
    BF_A = 0
    F_A = 16
    FS_A = 0
    true_A = 27

The next rules are strictly ordered:

  p4

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p5: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p6: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p7: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p8: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p9: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p10: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p11: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p12: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p13: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p14: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p15: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p4: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p5: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p6: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p7: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p8: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p9: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p10: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p11: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p12: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p13: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p14: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p15: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 27, x2 + 28, x3 + 18}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = x1 + 27
    S_A = 6
    closed_A = 0
    stop_A = 10
    true_A = 31
    false_A = 13
    down_A = 2
    F_A = 6
    up_A = 11
    B_A = 2
    FS_A = 6
    BF_A = 6

The next rules are strictly ordered:

  p9

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p4: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p5: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p6: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p7: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p8: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p9: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p10: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p11: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p12: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p13: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p14: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p5: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p6: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p7: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p8: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p9: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p11: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p12: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p13: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p14: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x1 - 17, x2 - 2, x3 - 9, x7 - 3}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x1 - 17, x3 - 9, x7 - 2}
    B_A = 20
    closed_A = 0
    down_A = 0
    stop_A = 11
    S_A = 19
    up_A = 11
    F_A = 14
    false_A = 5
    FS_A = 19
    BF_A = 0
    true_A = 2

The next rules are strictly ordered:

  p9, p12

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p5: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p6: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p7: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p8: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p9: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p10: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p11: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p12: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p4: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p5: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p6: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p7: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p8: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p9: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p10: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p11: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p12: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 18, x2 + 16, x3 + 1, x5 + 12, x7 + 15}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 18, x2 + 15, x3 + 1, x5 + 12, x7 + 17}
    S_A = 5
    closed_A = 0
    stop_A = 18
    true_A = 8
    false_A = 0
    down_A = 18
    F_A = 5
    up_A = 0
    B_A = 0
    FS_A = 5
    BF_A = 5

The next rules are strictly ordered:

  p4

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)
p3: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p4: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p5: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p6: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p7: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p8: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p9: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p10: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p11: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p5: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p6: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p7: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p8: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p9: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p10: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p11: busy#(S(),closed(),stop(),true(),false(),false(),i) -> idle#(S(),closed(),down(),true(),false(),false(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x2 + 9, x3 + 11, x4 + 8, x5 + 3, x6 + 3, x7 + 8}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x2 + 9, x3 + 11, x4 + 8, x5 + 3, x6 + 3, x7 + 11}
    B_A = 11
    closed_A = 0
    down_A = 0
    stop_A = 1
    S_A = 5
    up_A = 1
    F_A = 1
    false_A = 2
    FS_A = 0
    BF_A = 1
    true_A = 0

The next rules are strictly ordered:

  p11

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p5: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p6: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p7: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p8: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p9: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p10: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p3: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p4: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p5: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p6: busy#(S(),closed(),down(),b1,b2,false(),i) -> idle#(FS(),closed(),down(),b1,b2,false(),i)
p7: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p8: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p9: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p10: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x2, x3 - 3, x6 + 3}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x3 - 3, x6 + 3}
    F_A = 16
    closed_A = 0
    stop_A = 0
    false_A = 3
    true_A = 0
    up_A = 19
    B_A = 16
    FS_A = 0
    S_A = 15
    BF_A = 16
    down_A = 8

The next rules are strictly ordered:

  p6

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p3: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p4: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p5: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p6: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p7: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p8: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p9: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p5: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p6: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p7: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p8: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p9: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 5, x2 + 11, x5 + 1, x7 + 5}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 5, x2 + 11, x5 + 1, x7 + 11}
    B_A = 7
    closed_A = 1
    down_A = 5
    stop_A = 8
    S_A = 0
    up_A = 0
    F_A = 11
    false_A = 7
    FS_A = 1
    BF_A = 11
    true_A = 2

The next rules are strictly ordered:

  p4

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p5: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p6: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p7: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p8: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(F(),closed(),stop(),false(),false(),true(),i) -> idle#(F(),closed(),up(),false(),false(),true(),i)
p3: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p4: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p5: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p6: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p7: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p8: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 4, x2 - 1, x3 - 3, x5 - 5, x6 + 5, x7 - 1}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 4, x2 - 2, x3 - 3, x5 - 5, x6 + 5, x7 + 2}
    F_A = 0
    closed_A = 0
    stop_A = 18
    false_A = 19
    true_A = 9
    up_A = 0
    B_A = 20
    FS_A = 20
    S_A = 20
    BF_A = 5
    down_A = 7

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p3: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p4: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p5: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p6: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p7: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p5: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p6: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p7: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{4, x1 - 6, x2 - 2, x3 - 8, x7 - 1}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 6, x2 - 3, x3 - 9, x7 + 4}
    B_A = 5
    closed_A = 0
    down_A = 0
    stop_A = 10
    S_A = 7
    up_A = 12
    F_A = 0
    false_A = 0
    BF_A = 2
    FS_A = 11
    true_A = 6

The next rules are strictly ordered:

  p6

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p5: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p6: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),stop(),false(),true(),b3,i) -> idle#(B(),closed(),up(),false(),true(),b3,i)
p3: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p4: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p5: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p6: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 + 4, x3 + 10, x4 + 6, x5 - 1, x7 + 6}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 + 3, x3 + 10, x4 + 6, x5 - 1, x7 + 10}
    B_A = 3
    closed_A = 0
    stop_A = 1
    false_A = 2
    true_A = 10
    up_A = 0
    BF_A = 0
    F_A = 3
    down_A = 1
    S_A = 12

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p3: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p4: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p5: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p4: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p5: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 2, x2 + 1, x3 - 4, x7}
    empty_A = 1
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{2, x1 + 1, x3 - 4, x7 + 1}
    B_A = 0
    closed_A = 1
    down_A = 0
    stop_A = 2
    S_A = 2
    up_A = 9
    F_A = 0
    false_A = 0
    BF_A = 0

The next rules are strictly ordered:

  p3

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p4: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p3: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p4: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 4, x2 + 2, x3 + 2, x7 + 3}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 3, x2 + 1, x3 + 2, x7 + 4}
    BF_A = 2
    closed_A = 0
    up_A = 7
    F_A = 4
    down_A = 1
    false_A = 0
    B_A = 0
    stop_A = 2

The next rules are strictly ordered:

  p3

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p3: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)
p3: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 2, x2 + 2, x3 + 1, x7 + 1}
    empty_A = 0
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 2, x2 + 2, x3 + 1, x7 + 2}
    B_A = 0
    closed_A = 0
    down_A = 1
    stop_A = 0
    BF_A = 2
    up_A = 2
    F_A = 0

The next rules are strictly ordered:

  p3

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())
p2: busy#(B(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),stop(),b1,b2,b3,i)

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  max/plus interpretations on natural numbers:
  
    idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{6, x1 + 4, x2 + 2, x3 + 1, x7 + 4}
    empty_A = 1
    busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 4, x2 + 2, x3 + 1, x7 + 5}
    B_A = 0
    closed_A = 0
    down_A = 6
    stop_A = 0

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: idle#(fl,d,m,b1,b2,b3,empty()) -> busy#(fl,d,m,b1,b2,b3,empty())

and R consists of:

r1: start(i) -> busy(F(),closed(),stop(),false(),false(),false(),i)
r2: busy(BF(),d,stop(),b1,b2,b3,i) -> incorrect()
r3: busy(FS(),d,stop(),b1,b2,b3,i) -> incorrect()
r4: busy(fl,open(),up(),b1,b2,b3,i) -> incorrect()
r5: busy(fl,open(),down(),b1,b2,b3,i) -> incorrect()
r6: busy(B(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r7: busy(F(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r8: busy(S(),closed(),stop(),false(),false(),false(),empty()) -> correct()
r9: busy(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(B(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r10: busy(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(F(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r11: busy(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i)) -> idle(S(),closed(),stop(),false(),false(),false(),newbuttons(i1,i2,i3,i))
r12: busy(B(),open(),stop(),false(),b2,b3,i) -> idle(B(),closed(),stop(),false(),b2,b3,i)
r13: busy(F(),open(),stop(),b1,false(),b3,i) -> idle(F(),closed(),stop(),b1,false(),b3,i)
r14: busy(S(),open(),stop(),b1,b2,false(),i) -> idle(S(),closed(),stop(),b1,b2,false(),i)
r15: busy(B(),d,stop(),true(),b2,b3,i) -> idle(B(),open(),stop(),false(),b2,b3,i)
r16: busy(F(),d,stop(),b1,true(),b3,i) -> idle(F(),open(),stop(),b1,false(),b3,i)
r17: busy(S(),d,stop(),b1,b2,true(),i) -> idle(S(),open(),stop(),b1,b2,false(),i)
r18: busy(B(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),stop(),b1,b2,b3,i)
r19: busy(S(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),stop(),b1,b2,b3,i)
r20: busy(B(),closed(),up(),true(),b2,b3,i) -> idle(B(),closed(),stop(),true(),b2,b3,i)
r21: busy(F(),closed(),up(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r22: busy(F(),closed(),down(),b1,true(),b3,i) -> idle(F(),closed(),stop(),b1,true(),b3,i)
r23: busy(S(),closed(),down(),b1,b2,true(),i) -> idle(S(),closed(),stop(),b1,b2,true(),i)
r24: busy(B(),closed(),up(),false(),b2,b3,i) -> idle(BF(),closed(),up(),false(),b2,b3,i)
r25: busy(F(),closed(),up(),b1,false(),b3,i) -> idle(FS(),closed(),up(),b1,false(),b3,i)
r26: busy(F(),closed(),down(),b1,false(),b3,i) -> idle(BF(),closed(),down(),b1,false(),b3,i)
r27: busy(S(),closed(),down(),b1,b2,false(),i) -> idle(FS(),closed(),down(),b1,b2,false(),i)
r28: busy(BF(),closed(),up(),b1,b2,b3,i) -> idle(F(),closed(),up(),b1,b2,b3,i)
r29: busy(BF(),closed(),down(),b1,b2,b3,i) -> idle(B(),closed(),down(),b1,b2,b3,i)
r30: busy(FS(),closed(),up(),b1,b2,b3,i) -> idle(S(),closed(),up(),b1,b2,b3,i)
r31: busy(FS(),closed(),down(),b1,b2,b3,i) -> idle(F(),closed(),down(),b1,b2,b3,i)
r32: busy(B(),closed(),stop(),false(),true(),b3,i) -> idle(B(),closed(),up(),false(),true(),b3,i)
r33: busy(B(),closed(),stop(),false(),false(),true(),i) -> idle(B(),closed(),up(),false(),false(),true(),i)
r34: busy(F(),closed(),stop(),true(),false(),b3,i) -> idle(F(),closed(),down(),true(),false(),b3,i)
r35: busy(F(),closed(),stop(),false(),false(),true(),i) -> idle(F(),closed(),up(),false(),false(),true(),i)
r36: busy(S(),closed(),stop(),b1,true(),false(),i) -> idle(S(),closed(),down(),b1,true(),false(),i)
r37: busy(S(),closed(),stop(),true(),false(),false(),i) -> idle(S(),closed(),down(),true(),false(),false(),i)
r38: idle(fl,d,m,b1,b2,b3,empty()) -> busy(fl,d,m,b1,b2,b3,empty())
r39: 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)
r40: or(true(),b) -> true()
r41: or(false(),b) -> b

The estimated dependency graph contains the following SCCs:

  (no SCCs)