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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x2 - 13, x3 - 37, x4 - 2, x5 + 3, x6 + 6, x7 + 1}
      F_A = 0
      closed_A = 0
      stop_A = 0
      false_A = 0
      newbuttons_A(x1,x2,x3,x4) = max{x1 + 11, x2 + 11, x3 + 11, x4 + 4}
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 58, x2 - 3, x3 - 16, x4 - 2, x5 + 3, x6 + 6, x7 - 3}
      or_A(x1,x2) = max{x1 - 1, x2 + 1}
      S_A = 53
      true_A = 0
      down_A = 22
      empty_A = 1
      up_A = 18
      B_A = 44
      FS_A = 64
      BF_A = 22
      open_A = 9
    
    2. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      F_A = 0
      closed_A = 0
      stop_A = 0
      false_A = 0
      newbuttons_A(x1,x2,x3,x4) = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      or_A(x1,x2) = 0
      S_A = 0
      true_A = 1
      down_A = 0
      empty_A = 0
      up_A = 0
      B_A = 0
      FS_A = 0
      BF_A = 0
      open_A = 0
    

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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 16, x2 + 32, x3 - 7, x4 - 6, x5 + 9, x6 + 14, x7 + 31}
      newbuttons_A(x1,x2,x3,x4) = max{x1 - 20, x2 - 6, x3 - 1, x4 + 2}
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 14, x2 + 27, x3 - 8, x4 - 6, x5 + 9, x6 + 14, x7 + 32}
      or_A(x1,x2) = max{x1 - 1, x2 + 15}
      B_A = 13
      open_A = 0
      stop_A = 8
      false_A = 8
      closed_A = 0
      empty_A = 0
      F_A = 0
      S_A = 2
      true_A = 14
      down_A = 0
      up_A = 1
      BF_A = 16
      FS_A = 10
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      newbuttons_A(x1,x2,x3,x4) = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      or_A(x1,x2) = 1
      B_A = 0
      open_A = 0
      stop_A = 0
      false_A = 0
      closed_A = 0
      empty_A = 0
      F_A = 0
      S_A = 0
      true_A = 0
      down_A = 0
      up_A = 0
      BF_A = 0
      FS_A = 0
    

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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x3 + 6, x5 + 7, x7 + 2}
      B_A = 0
      open_A = 0
      stop_A = 0
      false_A = 4
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x3 + 7, x5 + 7, x7 + 1}
      closed_A = 41
      empty_A = 0
      S_A = 57
      true_A = 21
      down_A = 0
      F_A = 35
      up_A = 0
      FS_A = 47
      BF_A = 14
    
    2. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      open_A = 0
      stop_A = 0
      false_A = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      closed_A = 0
      empty_A = 0
      S_A = 0
      true_A = 0
      down_A = 0
      F_A = 0
      up_A = 0
      FS_A = 0
      BF_A = 0
    

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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x4 - 19, x7 - 2}
      B_A = 2
      open_A = 32
      stop_A = 0
      false_A = 21
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x2 - 35, x3 - 95, x4 - 19, x7 - 3}
      closed_A = 9
      empty_A = 2
      F_A = 49
      S_A = 39
      true_A = 28
      down_A = 76
      up_A = 53
      BF_A = 21
      FS_A = 0
    
    2. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      open_A = 0
      stop_A = 0
      false_A = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      closed_A = 0
      empty_A = 0
      F_A = 0
      S_A = 0
      true_A = 0
      down_A = 0
      up_A = 0
      BF_A = 0
      FS_A = 0
    

The next rules are strictly ordered:

  p5

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#(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#(F(),closed(),down(),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(),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#(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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x3 - 17, x4 + 22}
      B_A = 2
      open_A = 26
      stop_A = 0
      false_A = 22
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 24, x3 - 17, x4 + 22}
      closed_A = 11
      empty_A = 0
      S_A = 46
      true_A = 2
      down_A = 39
      F_A = 0
      up_A = 60
      FS_A = 31
      BF_A = 20
    
    2. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      open_A = 0
      stop_A = 0
      false_A = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      closed_A = 0
      empty_A = 0
      S_A = 0
      true_A = 0
      down_A = 0
      F_A = 0
      up_A = 0
      FS_A = 0
      BF_A = 0
    

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: 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#(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#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,i)
p9: busy#(F(),closed(),down(),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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x2 + 1, x6 + 78, x7 + 78}
      B_A = 58
      open_A = 82
      stop_A = 54
      false_A = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 2, x2 + 2, x3 + 6, x6 + 78, x7 + 72}
      closed_A = 60
      empty_A = 0
      F_A = 75
      S_A = 0
      true_A = 7
      down_A = 0
      up_A = 31
      BF_A = 71
      FS_A = 31
    
    2. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      open_A = 0
      stop_A = 0
      false_A = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      closed_A = 0
      empty_A = 0
      F_A = 0
      S_A = 0
      true_A = 0
      down_A = 0
      up_A = 0
      BF_A = 0
      FS_A = 0
    

The next rules are strictly ordered:

  p4, p5

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#(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#(F(),closed(),down(),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 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#(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#(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#(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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 20, x2 + 2, x3 + 4, x5 + 29, x7 + 2}
      B_A = 2
      open_A = 28
      stop_A = 16
      false_A = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 + 3, x3 + 6, x5 + 29, x7 + 1}
      closed_A = 0
      empty_A = 0
      S_A = 0
      true_A = 11
      down_A = 0
      F_A = 22
      up_A = 2
      FS_A = 8
      BF_A = 29
    
    2. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      open_A = 0
      stop_A = 0
      false_A = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      closed_A = 0
      empty_A = 0
      S_A = 0
      true_A = 0
      down_A = 0
      F_A = 0
      up_A = 0
      FS_A = 0
      BF_A = 0
    

The next rules are strictly ordered:

  p22

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#(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)

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: 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#(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#(F(),closed(),down(),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 set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 12, x2 + 5, x3, x4 + 12, x7 + 10}
      B_A = 13
      open_A = 15
      stop_A = 0
      false_A = 7
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 9, x2 + 5, x3, x4 + 12, x7 - 1}
      closed_A = 0
      empty_A = 0
      down_A = 12
      S_A = 7
      up_A = 13
      F_A = 18
      true_A = 2
      BF_A = 20
      FS_A = 0
    
    2. max/plus interpretations on natural numbers:
    
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      open_A = 0
      stop_A = 0
      false_A = 0
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      closed_A = 0
      empty_A = 0
      down_A = 0
      S_A = 0
      up_A = 0
      F_A = 0
      true_A = 0
      BF_A = 0
      FS_A = 0
    

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#(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#(F(),closed(),down(),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 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#(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(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,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)

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:

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

The next rules are strictly ordered:

  p16

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#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,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 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#(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#(F(),closed(),down(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,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 set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x2 + 3, x3 + 17, x5 + 4, x7 + 15}
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 1, x2 + 3, x3 + 17, x5 + 4, x7 + 16}
      B_A = 1
      closed_A = 0
      down_A = 1
      stop_A = 0
      S_A = 17
      up_A = 0
      F_A = 12
      true_A = 7
      false_A = 14
      BF_A = 0
      FS_A = 17
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      closed_A = 0
      down_A = 0
      stop_A = 0
      S_A = 0
      up_A = 0
      F_A = 0
      true_A = 0
      false_A = 0
      BF_A = 0
      FS_A = 0
    

The next rules are strictly ordered:

  p5

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#(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 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#(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#(F(),closed(),up(),b1,true(),b3,i) -> idle#(F(),closed(),stop(),b1,true(),b3,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 set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p3, p16

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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{1, x1 - 1, x2 - 1, x3 - 8, x4 - 7, x5 - 2}
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x1 - 1, x2 - 1, x3 - 8, x4 - 7, x5 - 2}
      B_A = 4
      closed_A = 0
      down_A = 13
      stop_A = 13
      S_A = 7
      up_A = 0
      false_A = 9
      BF_A = 2
      F_A = 2
      FS_A = 7
      true_A = 0
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      closed_A = 0
      down_A = 0
      stop_A = 0
      S_A = 0
      up_A = 0
      false_A = 0
      BF_A = 0
      F_A = 0
      FS_A = 0
      true_A = 0
    

The next rules are strictly ordered:

  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#(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(),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#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p7: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),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#(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#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,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:

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

The next rules are strictly ordered:

  p10

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#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p7: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),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#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p10: busy#(F(),closed(),down(),b1,false(),b3,i) -> idle#(BF(),closed(),down(),b1,false(),b3,i)
p11: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p12: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,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#(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#(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(),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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 15, x2 + 17, x3 + 2, x4 + 18, x5 + 3, x7 + 17}
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 15, x2 + 16, x3 + 1, x4 + 18, x5 + 3, x7 + 18}
      B_A = 16
      closed_A = 0
      down_A = 0
      stop_A = 25
      S_A = 10
      up_A = 27
      false_A = 12
      BF_A = 16
      F_A = 16
      FS_A = 16
      true_A = 6
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      closed_A = 0
      down_A = 0
      stop_A = 0
      S_A = 0
      up_A = 0
      false_A = 0
      BF_A = 0
      F_A = 0
      FS_A = 0
      true_A = 0
    

The next rules are strictly ordered:

  p14

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#(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(),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)

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}


-- 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#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p4: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p5: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p6: busy#(FS(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),up(),b1,b2,b3,i)
p7: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p8: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,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#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p12: busy#(S(),closed(),up(),b1,b2,b3,i) -> idle#(S(),closed(),stop(),b1,b2,b3,i)
p13: 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:

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

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#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p4: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p5: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p6: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p7: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,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#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,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 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#(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#(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(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(B(),closed(),stop(),false(),false(),true(),i) -> idle#(B(),closed(),up(),false(),false(),true(),i)
p11: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p12: 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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 + 11, x3 + 13, x4 - 1, x6 + 7, x7 - 3}
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 + 11, x3 + 13, x4 - 1, x6 + 7, x7 - 2}
      B_A = 15
      closed_A = 0
      down_A = 2
      stop_A = 2
      S_A = 17
      up_A = 1
      false_A = 11
      BF_A = 7
      F_A = 5
      FS_A = 14
      true_A = 2
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      closed_A = 0
      down_A = 0
      stop_A = 0
      S_A = 0
      up_A = 0
      false_A = 0
      BF_A = 0
      F_A = 0
      FS_A = 0
      true_A = 0
    

The next rules are strictly ordered:

  p10, 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#(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#(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(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p10: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),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}


-- 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(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p3: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p4: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),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#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,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:

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

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#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p3: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p4: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),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#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),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#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),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#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p8: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p9: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),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:

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

The next rules are strictly ordered:

  p5

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#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),b2,b3,i)
p4: busy#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p5: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p6: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p7: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p8: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),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}


-- 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(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p3: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p4: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),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(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p7: busy#(B(),closed(),up(),false(),b2,b3,i) -> idle#(BF(),closed(),up(),false(),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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 9, x2 + 1, x3 - 10, x4 + 4, x7 - 9}
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 14, x3 - 10, x4 + 4, x7 - 8}
      F_A = 8
      closed_A = 0
      stop_A = 21
      true_A = 1
      false_A = 0
      down_A = 21
      FS_A = 12
      BF_A = 0
      B_A = 19
      up_A = 0
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      F_A = 0
      closed_A = 0
      stop_A = 0
      true_A = 0
      false_A = 0
      down_A = 0
      FS_A = 0
      BF_A = 0
      B_A = 0
      up_A = 0
    

The next rules are strictly ordered:

  p7

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(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),false(),b3,i)
p3: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p4: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),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(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),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#(F(),closed(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p4: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p5: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p6: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p7: busy#(F(),closed(),stop(),true(),false(),b3,i) -> idle#(F(),closed(),down(),true(),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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 3, x2 + 14, x3 + 3, x5 + 15, x7 + 1}
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 3, x2 + 13, x3 + 2, x5 + 15, x7 + 2}
      B_A = 15
      closed_A = 0
      down_A = 2
      stop_A = 14
      F_A = 9
      up_A = 8
      false_A = 0
      FS_A = 6
      BF_A = 16
      true_A = 8
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      B_A = 0
      closed_A = 0
      down_A = 0
      stop_A = 0
      F_A = 0
      up_A = 0
      false_A = 0
      FS_A = 0
      BF_A = 0
      true_A = 0
    

The next rules are strictly ordered:

  p7

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(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),b3,i)
p4: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p5: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p6: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),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}


-- 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#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p3: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),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(),up(),b1,false(),b3,i) -> idle#(FS(),closed(),up(),b1,false(),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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{2, x1 - 4, x2 - 1, x3 - 3, x5 - 3, x7 - 3}
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{0, x1 - 4, x2 - 2, x3 - 3, x5 - 3, x7 - 2}
      FS_A = 0
      closed_A = 0
      down_A = 8
      F_A = 7
      BF_A = 8
      B_A = 5
      up_A = 0
      false_A = 0
      stop_A = 4
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      FS_A = 0
      closed_A = 0
      down_A = 0
      F_A = 0
      BF_A = 0
      B_A = 0
      up_A = 0
      false_A = 0
      stop_A = 0
    

The next rules are strictly ordered:

  p5

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#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),b1,b2,b3,i)
p3: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p4: busy#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),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#(BF(),closed(),up(),b1,b2,b3,i) -> idle#(F(),closed(),up(),b1,b2,b3,i)
p4: busy#(BF(),closed(),down(),b1,b2,b3,i) -> idle#(B(),closed(),down(),b1,b2,b3,i)
p5: busy#(FS(),closed(),down(),b1,b2,b3,i) -> idle#(F(),closed(),down(),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:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 + 6, x2 + 4, x3 - 2, x7 + 5}
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = max{x1 - 1, x2 + 3, x3 - 5, x7 + 5}
      B_A = 0
      closed_A = 0
      down_A = 12
      stop_A = 0
      BF_A = 11
      up_A = 4
      F_A = 0
      FS_A = 12
    
    2. max/plus interpretations on natural numbers:
    
      idle#_A(x1,x2,x3,x4,x5,x6,x7) = 0
      empty_A = 0
      busy#_A(x1,x2,x3,x4,x5,x6,x7) = 1
      B_A = 0
      closed_A = 0
      down_A = 0
      stop_A = 0
      BF_A = 0
      up_A = 0
      F_A = 0
      FS_A = 0
    

The next rules are strictly ordered:

  p1, p2, p3, p4, p5

We remove them from the problem.  Then no dependency pair remains.