YES
We show the termination of the TRS R:

  or(T(),T()) -> T()
  or(F(),T()) -> T()
  or(T(),F()) -> T()
  or(F(),F()) -> F()
  and(T(),B) -> B
  and(B,T()) -> B
  and(F(),B) -> F()
  and(B,F()) -> F()
  imp(T(),B) -> B
  imp(F(),B) -> T()
  not(T()) -> F()
  not(F()) -> T()
  if(T(),B1,B2) -> B1
  if(F(),B1,B2) -> B2
  eq(T(),T()) -> T()
  eq(F(),F()) -> T()
  eq(T(),F()) -> F()
  eq(F(),T()) -> F()
  eqt(nil(),undefined()) -> F()
  eqt(nil(),pid(N2)) -> F()
  eqt(nil(),int(N2)) -> F()
  eqt(nil(),cons(H2,T2)) -> F()
  eqt(nil(),tuple(H2,T2)) -> F()
  eqt(nil(),tuplenil(H2)) -> F()
  eqt(a(),nil()) -> F()
  eqt(a(),a()) -> T()
  eqt(a(),excl()) -> F()
  eqt(a(),false()) -> F()
  eqt(a(),lock()) -> F()
  eqt(a(),locker()) -> F()
  eqt(a(),mcrlrecord()) -> F()
  eqt(a(),ok()) -> F()
  eqt(a(),pending()) -> F()
  eqt(a(),release()) -> F()
  eqt(a(),request()) -> F()
  eqt(a(),resource()) -> F()
  eqt(a(),tag()) -> F()
  eqt(a(),true()) -> F()
  eqt(a(),undefined()) -> F()
  eqt(a(),pid(N2)) -> F()
  eqt(a(),int(N2)) -> F()
  eqt(a(),cons(H2,T2)) -> F()
  eqt(a(),tuple(H2,T2)) -> F()
  eqt(a(),tuplenil(H2)) -> F()
  eqt(excl(),nil()) -> F()
  eqt(excl(),a()) -> F()
  eqt(excl(),excl()) -> T()
  eqt(excl(),false()) -> F()
  eqt(excl(),lock()) -> F()
  eqt(excl(),locker()) -> F()
  eqt(excl(),mcrlrecord()) -> F()
  eqt(excl(),ok()) -> F()
  eqt(excl(),pending()) -> F()
  eqt(excl(),release()) -> F()
  eqt(excl(),request()) -> F()
  eqt(excl(),resource()) -> F()
  eqt(excl(),tag()) -> F()
  eqt(excl(),true()) -> F()
  eqt(excl(),undefined()) -> F()
  eqt(excl(),pid(N2)) -> F()
  eqt(excl(),eqt(false(),int(N2))) -> F()
  eqt(false(),cons(H2,T2)) -> F()
  eqt(false(),tuple(H2,T2)) -> F()
  eqt(false(),tuplenil(H2)) -> F()
  eqt(lock(),nil()) -> F()
  eqt(lock(),a()) -> F()
  eqt(lock(),excl()) -> F()
  eqt(lock(),false()) -> F()
  eqt(lock(),lock()) -> T()
  eqt(lock(),locker()) -> F()
  eqt(lock(),mcrlrecord()) -> F()
  eqt(lock(),ok()) -> F()
  eqt(lock(),pending()) -> F()
  eqt(lock(),release()) -> F()
  eqt(lock(),request()) -> F()
  eqt(lock(),resource()) -> F()
  eqt(lock(),tag()) -> F()
  eqt(lock(),true()) -> F()
  eqt(lock(),undefined()) -> F()
  eqt(lock(),pid(N2)) -> F()
  eqt(lock(),int(N2)) -> F()
  eqt(lock(),cons(H2,T2)) -> F()
  eqt(lock(),tuple(H2,T2)) -> F()
  eqt(lock(),tuplenil(H2)) -> F()
  eqt(locker(),nil()) -> F()
  eqt(locker(),a()) -> F()
  eqt(locker(),excl()) -> F()
  eqt(locker(),false()) -> F()
  eqt(locker(),lock()) -> F()
  eqt(locker(),locker()) -> T()
  eqt(locker(),mcrlrecord()) -> F()
  eqt(locker(),ok()) -> F()
  eqt(locker(),pending()) -> F()
  eqt(locker(),release()) -> F()
  eqt(locker(),request()) -> F()
  eqt(locker(),resource()) -> F()
  eqt(locker(),tag()) -> F()
  eqt(locker(),true()) -> F()
  eqt(locker(),undefined()) -> F()
  eqt(locker(),pid(N2)) -> F()
  eqt(locker(),int(N2)) -> F()
  eqt(locker(),cons(H2,T2)) -> F()
  eqt(locker(),tuple(H2,T2)) -> F()
  eqt(locker(),tuplenil(H2)) -> F()
  eqt(mcrlrecord(),nil()) -> F()
  eqt(mcrlrecord(),a()) -> F()
  eqt(mcrlrecord(),excl()) -> F()
  eqt(mcrlrecord(),false()) -> F()
  eqt(mcrlrecord(),lock()) -> F()
  eqt(mcrlrecord(),locker()) -> F()
  eqt(mcrlrecord(),mcrlrecord()) -> T()
  eqt(mcrlrecord(),ok()) -> F()
  eqt(mcrlrecord(),pending()) -> F()
  eqt(mcrlrecord(),release()) -> F()
  eqt(mcrlrecord(),request()) -> F()
  eqt(mcrlrecord(),resource()) -> F()
  eqt(ok(),resource()) -> F()
  eqt(ok(),tag()) -> F()
  eqt(ok(),true()) -> F()
  eqt(ok(),undefined()) -> F()
  eqt(ok(),pid(N2)) -> F()
  eqt(ok(),int(N2)) -> F()
  eqt(ok(),cons(H2,T2)) -> F()
  eqt(ok(),tuple(H2,T2)) -> F()
  eqt(ok(),tuplenil(H2)) -> F()
  eqt(pending(),nil()) -> F()
  eqt(pending(),a()) -> F()
  eqt(pending(),excl()) -> F()
  eqt(pending(),false()) -> F()
  eqt(pending(),lock()) -> F()
  eqt(pending(),locker()) -> F()
  eqt(pending(),mcrlrecord()) -> F()
  eqt(pending(),ok()) -> F()
  eqt(pending(),pending()) -> T()
  eqt(pending(),release()) -> F()
  eqt(pending(),request()) -> F()
  eqt(pending(),resource()) -> F()
  eqt(pending(),tag()) -> F()
  eqt(pending(),true()) -> F()
  eqt(pending(),undefined()) -> F()
  eqt(pending(),pid(N2)) -> F()
  eqt(pending(),int(N2)) -> F()
  eqt(pending(),cons(H2,T2)) -> F()
  eqt(pending(),tuple(H2,T2)) -> F()
  eqt(pending(),tuplenil(H2)) -> F()
  eqt(release(),nil()) -> F()
  eqt(release(),a()) -> F()
  eqt(release(),excl()) -> F()
  eqt(release(),false()) -> F()
  eqt(release(),lock()) -> F()
  eqt(release(),locker()) -> F()
  eqt(release(),mcrlrecord()) -> F()
  eqt(release(),ok()) -> F()
  eqt(request(),mcrlrecord()) -> F()
  eqt(request(),ok()) -> F()
  eqt(request(),pending()) -> F()
  eqt(request(),release()) -> F()
  eqt(request(),request()) -> T()
  eqt(request(),resource()) -> F()
  eqt(request(),tag()) -> F()
  eqt(request(),true()) -> F()
  eqt(request(),undefined()) -> F()
  eqt(request(),pid(N2)) -> F()
  eqt(request(),int(N2)) -> F()
  eqt(request(),cons(H2,T2)) -> F()
  eqt(request(),tuple(H2,T2)) -> F()
  eqt(request(),tuplenil(H2)) -> F()
  eqt(resource(),nil()) -> F()
  eqt(resource(),a()) -> F()
  eqt(resource(),excl()) -> F()
  eqt(resource(),false()) -> F()
  eqt(resource(),lock()) -> F()
  eqt(resource(),locker()) -> F()
  eqt(resource(),mcrlrecord()) -> F()
  eqt(resource(),ok()) -> F()
  eqt(resource(),pending()) -> F()
  eqt(resource(),release()) -> F()
  eqt(resource(),request()) -> F()
  eqt(resource(),resource()) -> T()
  eqt(resource(),tag()) -> F()
  eqt(resource(),true()) -> F()
  eqt(resource(),undefined()) -> F()
  eqt(resource(),pid(N2)) -> F()
  eqt(resource(),int(N2)) -> F()
  eqt(resource(),cons(H2,T2)) -> F()
  eqt(resource(),tuple(H2,T2)) -> F()
  eqt(resource(),tuplenil(H2)) -> F()
  eqt(tag(),nil()) -> F()
  eqt(tag(),a()) -> F()
  eqt(tag(),excl()) -> F()
  eqt(tag(),false()) -> F()
  eqt(tag(),lock()) -> F()
  eqt(tag(),locker()) -> F()
  eqt(tag(),mcrlrecord()) -> F()
  eqt(tag(),ok()) -> F()
  eqt(tag(),pending()) -> F()
  eqt(tag(),release()) -> F()
  eqt(tag(),request()) -> F()
  eqt(tag(),resource()) -> F()
  eqt(tag(),tag()) -> T()
  eqt(tag(),true()) -> F()
  eqt(tag(),undefined()) -> F()
  eqt(tag(),pid(N2)) -> F()
  eqt(tag(),int(N2)) -> F()
  eqt(tag(),cons(H2,T2)) -> F()
  eqt(tag(),tuple(H2,T2)) -> F()
  eqt(tag(),tuplenil(H2)) -> F()
  eqt(true(),nil()) -> F()
  eqt(true(),a()) -> F()
  eqt(true(),excl()) -> F()
  eqt(true(),false()) -> F()
  eqt(true(),lock()) -> F()
  eqt(true(),locker()) -> F()
  eqt(true(),mcrlrecord()) -> F()
  eqt(true(),ok()) -> F()
  eqt(true(),pending()) -> F()
  eqt(true(),release()) -> F()
  eqt(true(),request()) -> F()
  eqt(true(),resource()) -> F()
  eqt(true(),tag()) -> F()
  eqt(true(),true()) -> T()
  eqt(true(),undefined()) -> F()
  eqt(true(),pid(N2)) -> F()
  eqt(true(),int(N2)) -> F()
  eqt(true(),cons(H2,T2)) -> F()
  eqt(true(),tuple(H2,T2)) -> F()
  eqt(true(),tuplenil(H2)) -> F()
  eqt(undefined(),nil()) -> F()
  eqt(undefined(),a()) -> F()
  eqt(undefined(),tuplenil(H2)) -> F()
  eqt(pid(N1),nil()) -> F()
  eqt(pid(N1),a()) -> F()
  eqt(pid(N1),excl()) -> F()
  eqt(pid(N1),false()) -> F()
  eqt(pid(N1),lock()) -> F()
  eqt(pid(N1),locker()) -> F()
  eqt(pid(N1),mcrlrecord()) -> F()
  eqt(pid(N1),ok()) -> F()
  eqt(pid(N1),pending()) -> F()
  eqt(pid(N1),release()) -> F()
  eqt(pid(N1),request()) -> F()
  eqt(pid(N1),resource()) -> F()
  eqt(pid(N1),tag()) -> F()
  eqt(pid(N1),true()) -> F()
  eqt(pid(N1),undefined()) -> F()
  eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
  eqt(pid(N1),int(N2)) -> F()
  eqt(pid(N1),cons(H2,T2)) -> F()
  eqt(pid(N1),tuple(H2,T2)) -> F()
  eqt(pid(N1),tuplenil(H2)) -> F()
  eqt(int(N1),nil()) -> F()
  eqt(int(N1),a()) -> F()
  eqt(int(N1),excl()) -> F()
  eqt(int(N1),false()) -> F()
  eqt(int(N1),lock()) -> F()
  eqt(int(N1),locker()) -> F()
  eqt(int(N1),mcrlrecord()) -> F()
  eqt(int(N1),ok()) -> F()
  eqt(int(N1),pending()) -> F()
  eqt(int(N1),release()) -> F()
  eqt(int(N1),request()) -> F()
  eqt(int(N1),resource()) -> F()
  eqt(int(N1),tag()) -> F()
  eqt(int(N1),true()) -> F()
  eqt(int(N1),undefined()) -> F()
  eqt(cons(H1,T1),resource()) -> F()
  eqt(cons(H1,T1),tag()) -> F()
  eqt(cons(H1,T1),true()) -> F()
  eqt(cons(H1,T1),undefined()) -> F()
  eqt(cons(H1,T1),pid(N2)) -> F()
  eqt(cons(H1,T1),int(N2)) -> F()
  eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
  eqt(cons(H1,T1),tuple(H2,T2)) -> F()
  eqt(cons(H1,T1),tuplenil(H2)) -> F()
  eqt(tuple(H1,T1),nil()) -> F()
  eqt(tuple(H1,T1),a()) -> F()
  eqt(tuple(H1,T1),excl()) -> F()
  eqt(tuple(H1,T1),false()) -> F()
  eqt(tuple(H1,T1),lock()) -> F()
  eqt(tuple(H1,T1),locker()) -> F()
  eqt(tuple(H1,T1),mcrlrecord()) -> F()
  eqt(tuple(H1,T1),ok()) -> F()
  eqt(tuple(H1,T1),pending()) -> F()
  eqt(tuple(H1,T1),release()) -> F()
  eqt(tuple(H1,T1),request()) -> F()
  eqt(tuple(H1,T1),resource()) -> F()
  eqt(tuple(H1,T1),tag()) -> F()
  eqt(tuple(H1,T1),true()) -> F()
  eqt(tuple(H1,T1),undefined()) -> F()
  eqt(tuple(H1,T1),pid(N2)) -> F()
  eqt(tuple(H1,T1),int(N2)) -> F()
  eqt(tuple(H1,T1),cons(H2,T2)) -> F()
  eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
  eqt(tuple(H1,T1),tuplenil(H2)) -> F()
  eqt(tuplenil(H1),nil()) -> F()
  eqt(tuplenil(H1),a()) -> F()
  eqt(tuplenil(H1),excl()) -> F()
  eqt(tuplenil(H1),false()) -> F()
  eqt(tuplenil(H1),lock()) -> F()
  eqt(tuplenil(H1),locker()) -> F()
  eqt(tuplenil(H1),mcrlrecord()) -> F()
  eqt(tuplenil(H1),ok()) -> F()
  eqt(tuplenil(H1),pending()) -> F()
  eqt(tuplenil(H1),release()) -> F()
  eqt(tuplenil(H1),request()) -> F()
  eqt(tuplenil(H1),resource()) -> F()
  eqt(tuplenil(H1),tag()) -> F()
  eqt(tuplenil(H1),true()) -> F()
  eqt(tuplenil(H1),undefined()) -> F()
  eqt(tuplenil(H1),pid(N2)) -> F()
  eqt(tuplenil(H1),int(N2)) -> F()
  eqt(tuplenil(H1),cons(H2,T2)) -> F()
  eqt(tuplenil(H1),tuple(H2,T2)) -> F()
  eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
  element(int(s(|0|())),tuplenil(T1)) -> T1
  element(int(s(|0|())),tuple(T1,T2)) -> T1
  element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
  record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
  record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
  record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
  record_updates(Record,Name,nil()) -> Record
  record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
  locker2_map_promote_pending(nil(),Pending) -> nil()
  locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
  locker2_map_claim_lock(nil(),Resources,Client) -> nil()
  locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
  locker2_map_add_pending(nil(),Resources,Client) -> nil()
  locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
  case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
  case0(Client,Lock,MCRLFree0) -> Lock
  locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
  locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
  case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
  case1(Client,Resources,Lock,false()) -> Lock
  locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
  case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
  case4(Client,Lock,MCRLFree1) -> false()
  locker2_obtainables(nil(),Client) -> true()
  locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
  case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
  case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
  locker2_check_available(Resource,nil()) -> false()
  locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
  case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
  case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
  locker2_check_availables(nil(),Locks) -> true()
  locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
  locker2_adduniq(nil(),List) -> List
  append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
  subtract(List,nil()) -> List
  subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
  delete(E,nil()) -> nil()
  delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
  case8(Tail,Head,E,true()) -> Tail
  case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
  gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
  gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
  member(E,nil()) -> false()
  member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
  case9(Tail,Head,E,true()) -> true()
  case9(Tail,Head,E,false()) -> member(E,Tail)
  eqs(empty(),empty()) -> T()
  eqs(empty(),stack(E2,S2)) -> F()
  eqs(stack(E1,S1),empty()) -> F()
  eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
  pushs(E1,S1) -> stack(E1,S1)
  pops(stack(E1,S1)) -> S1
  tops(stack(E1,S1)) -> E1
  istops(E1,empty()) -> F()
  istops(E1,stack(E2,S1)) -> eqt(E1,E2)
  eqc(nocalls(),nocalls()) -> T()
  eqc(nocalls(),calls(E2,S2,CS2)) -> F()
  eqc(calls(E1,S1,CS1),nocalls()) -> F()
  eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
  push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
  push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
  push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)


-- SCC decomposition.

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

p1: eqt#(pid(N1),pid(N2)) -> eqt#(N1,N2)
p2: eqt#(cons(H1,T1),cons(H2,T2)) -> and#(eqt(H1,H2),eqt(T1,T2))
p3: eqt#(cons(H1,T1),cons(H2,T2)) -> eqt#(H1,H2)
p4: eqt#(cons(H1,T1),cons(H2,T2)) -> eqt#(T1,T2)
p5: eqt#(tuple(H1,T1),tuple(H2,T2)) -> and#(eqt(H1,H2),eqt(T1,T2))
p6: eqt#(tuple(H1,T1),tuple(H2,T2)) -> eqt#(H1,H2)
p7: eqt#(tuple(H1,T1),tuple(H2,T2)) -> eqt#(T1,T2)
p8: eqt#(tuplenil(H1),tuplenil(H2)) -> eqt#(H1,H2)
p9: element#(int(s(s(N1))),tuple(T1,T2)) -> element#(int(s(N1)),T2)
p10: record_updates#(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates#(record_update(Record,Name,Field,NewF),Name,Fields)
p11: record_updates#(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_update#(Record,Name,Field,NewF)
p12: locker2_map_promote_pending#(cons(Lock,Locks),Pending) -> locker2_promote_pending#(Lock,Pending)
p13: locker2_map_promote_pending#(cons(Lock,Locks),Pending) -> locker2_map_promote_pending#(Locks,Pending)
p14: locker2_map_claim_lock#(cons(Lock,Locks),Resources,Client) -> locker2_map_claim_lock#(Locks,Resources,Client)
p15: locker2_promote_pending#(Lock,Client) -> case0#(Client,Lock,record_extract(Lock,lock(),pending()))
p16: locker2_promote_pending#(Lock,Client) -> record_extract#(Lock,lock(),pending())
p17: case0#(Client,Lock,cons(Client,Pendings)) -> record_updates#(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
p18: locker2_remove_pending#(Lock,Client) -> record_updates#(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
p19: locker2_remove_pending#(Lock,Client) -> subtract#(record_extract(Lock,lock(),pending()),cons(Client,nil()))
p20: locker2_remove_pending#(Lock,Client) -> record_extract#(Lock,lock(),pending())
p21: locker2_add_pending#(Lock,Resources,Client) -> case1#(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
p22: locker2_add_pending#(Lock,Resources,Client) -> member#(record_extract(Lock,lock(),resource()),Resources)
p23: locker2_add_pending#(Lock,Resources,Client) -> record_extract#(Lock,lock(),resource())
p24: case1#(Client,Resources,Lock,true()) -> record_updates#(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
p25: case1#(Client,Resources,Lock,true()) -> append#(record_extract(Lock,lock(),pending()),cons(Client,nil()))
p26: case1#(Client,Resources,Lock,true()) -> record_extract#(Lock,lock(),pending())
p27: locker2_release_lock#(Lock,Client) -> case2#(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
p28: locker2_release_lock#(Lock,Client) -> gen_modtageq#(Client,record_extract(Lock,lock(),excl()))
p29: locker2_release_lock#(Lock,Client) -> record_extract#(Lock,lock(),excl())
p30: case2#(Client,Lock,true()) -> record_updates#(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
p31: locker2_obtainables#(cons(Lock,Locks),Client) -> case5#(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
p32: locker2_obtainables#(cons(Lock,Locks),Client) -> member#(Client,record_extract(Lock,lock(),pending()))
p33: locker2_obtainables#(cons(Lock,Locks),Client) -> record_extract#(Lock,lock(),pending())
p34: case5#(Client,Locks,Lock,true()) -> locker2_obtainables#(Locks,Client)
p35: case5#(Client,Locks,Lock,false()) -> locker2_obtainables#(Locks,Client)
p36: locker2_check_available#(Resource,cons(Lock,Locks)) -> case6#(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
p37: locker2_check_available#(Resource,cons(Lock,Locks)) -> record_extract#(Lock,lock(),resource())
p38: case6#(Locks,Lock,Resource,true()) -> record_extract#(Lock,lock(),excl())
p39: case6#(Locks,Lock,Resource,true()) -> record_extract#(Lock,lock(),pending())
p40: case6#(Locks,Lock,Resource,false()) -> locker2_check_available#(Resource,Locks)
p41: locker2_check_availables#(cons(Resource,Resources),Locks) -> locker2_check_available#(Resource,Locks)
p42: locker2_check_availables#(cons(Resource,Resources),Locks) -> locker2_check_availables#(Resources,Locks)
p43: append#(cons(Head,Tail),List) -> append#(Tail,List)
p44: subtract#(List,cons(Head,Tail)) -> subtract#(delete(Head,List),Tail)
p45: subtract#(List,cons(Head,Tail)) -> delete#(Head,List)
p46: delete#(E,cons(Head,Tail)) -> case8#(Tail,Head,E,equal(E,Head))
p47: case8#(Tail,Head,E,false()) -> delete#(E,Tail)
p48: member#(E,cons(Head,Tail)) -> case9#(Tail,Head,E,equal(E,Head))
p49: case9#(Tail,Head,E,false()) -> member#(E,Tail)
p50: eqs#(stack(E1,S1),stack(E2,S2)) -> and#(eqt(E1,E2),eqs(S1,S2))
p51: eqs#(stack(E1,S1),stack(E2,S2)) -> eqt#(E1,E2)
p52: eqs#(stack(E1,S1),stack(E2,S2)) -> eqs#(S1,S2)
p53: istops#(E1,stack(E2,S1)) -> eqt#(E1,E2)
p54: eqc#(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and#(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
p55: eqc#(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> eqt#(E1,E2)
p56: eqc#(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and#(eqs(S1,S2),eqc(CS1,CS2))
p57: eqc#(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> eqs#(S1,S2)
p58: eqc#(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> eqc#(CS1,CS2)
p59: push#(E1,E2,calls(E3,S1,CS1)) -> push1#(E1,E2,E3,S1,CS1,eqt(E1,E3))
p60: push#(E1,E2,calls(E3,S1,CS1)) -> eqt#(E1,E3)
p61: push1#(E1,E2,E3,S1,CS1,T()) -> pushs#(E2,S1)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The estimated dependency graph contains the following SCCs:

  {p58}
  {p52}
  {p1, p3, p4, p6, p7, p8}
  {p9}
  {p10}
  {p13}
  {p14}
  {p44}
  {p42}
  {p43}


-- Reduction pair.

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

p1: eqc#(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> eqc#(CS1,CS2)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r1, r2, r3, r9, r13, r14, r339, r348, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          eqc#_A(x1,x2) = x1 + x2 + 14
          calls_A(x1,x2,x3) = x1 + x2 + x3 + 13
          or_A(x1,x2) = 12
          T_A() = 1
          F_A() = 11
          imp_A(x1,x2) = x2 + 2
          if_A(x1,x2,x3) = x1 + x2 + x3
          locker2_obtainables_A(x1,x2) = x2 + 55
          cons_A(x1,x2) = 51
          case5_A(x1,x2,x3,x4) = 2
          member_A(x1,x2) = x2 + 46
          record_extract_A(x1,x2,x3) = x1 + 46
          lock_A() = 48
          pending_A() = 12
          locker2_adduniq_A(x1,x2) = x2 + 1
          nil_A() = 14
          case9_A(x1,x2,x3,x4) = 50
          equal_A(x1,x2) = x2 + 8
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            eqc#_A(x1,x2) = x1 + x2
            calls_A(x1,x2,x3) = x1 + x3 + 1
            or_A(x1,x2) = 57
            T_A() = 57
            F_A() = 58
            imp_A(x1,x2) = x2
            if_A(x1,x2,x3) = x2 + x3
            locker2_obtainables_A(x1,x2) = 1
            cons_A(x1,x2) = x1 + 11
            case5_A(x1,x2,x3,x4) = 0
            member_A(x1,x2) = 1
            record_extract_A(x1,x2,x3) = 4
            lock_A() = 10
            pending_A() = 18
            locker2_adduniq_A(x1,x2) = x2
            nil_A() = 22
            case9_A(x1,x2,x3,x4) = 0
            equal_A(x1,x2) = 2
            eqc#!_A(x1,x2) = x1 + x2
            calls!_A(x1,x2,x3) = 23
            or!_A(x1,x2) = x2
            T!_A() = 25
            F!_A() = 21
            imp!_A(x1,x2) = 26
            if!_A(x1,x2,x3) = x1 + x2 + x3
            locker2_obtainables!_A(x1,x2) = 40
            cons!_A(x1,x2) = x2 + 20
            case5!_A(x1,x2,x3,x4) = 1
            member!_A(x1,x2) = x2 + 17
            record_extract!_A(x1,x2,x3) = x3 + 20
            lock!_A() = 20
            pending!_A() = 44
            locker2_adduniq!_A(x1,x2) = x1 + x2
            nil!_A() = 38
            case9!_A(x1,x2,x3,x4) = 42
            equal!_A(x1,x2) = 36
  
    partial status:
  
      pi(eqc#) = [1]
      pi(calls) = [2, 3]
      pi(or) = []
      pi(T) = []
      pi(F) = []
      pi(imp) = [2]
      pi(if) = [1, 2, 3]
      pi(locker2_obtainables) = [2]
      pi(cons) = []
      pi(case5) = []
      pi(member) = []
      pi(record_extract) = []
      pi(lock) = []
      pi(pending) = []
      pi(locker2_adduniq) = [2]
      pi(nil) = []
      pi(case9) = []
      pi(equal) = []

The following rules are removed:

  p1

Then no dependency pair remains.

-- Reduction pair.

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

p1: eqs#(stack(E1,S1),stack(E2,S2)) -> eqs#(S1,S2)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r9, r13, r14, r17, r18, r29, r42, r49, r52, r54, r60, r62, r66, r67, r68, r70, r72, r73, r74, r75, r76, r77, r78, r79, r80, r82, r83, r84, r89, r102, r121, r123, r130, r148, r150, r153, r165, r172, r185, r192, r212, r225, r233, r235, r238, r248, r255, r266, r268, r270, r274, r279, r297, r299, r312, r342, r348

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          eqs#_A(x1,x2) = x1 + x2 + 14
          stack_A(x1,x2) = x2 + 13
          imp_A(x1,x2) = x2 + 11
          T_A() = 10
          if_A(x1,x2,x3) = x2 + x3 + 1
          F_A() = 8
          eq_A(x1,x2) = x2 + 3
          eqt_A(x1,x2) = x2 + 5
          a_A() = 3
          lock_A() = 18
          cons_A(x1,x2) = 16
          excl_A() = 7
          ok_A() = 9
          release_A() = 9
          pid_A(x1) = 9
          false_A() = 9
          locker_A() = 4
          pending_A() = 20
          request_A() = 11
          resource_A() = 12
          tag_A() = 11
          true_A() = 16
          undefined_A() = 9
          tuple_A(x1,x2) = 4
          tuplenil_A(x1) = 9
          int_A(x1) = 2
          locker2_check_available_A(x1,x2) = 17
          nil_A() = 11
          locker2_adduniq_A(x1,x2) = x2 + 1
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            eqs#_A(x1,x2) = x1 + x2
            stack_A(x1,x2) = x2 + 2
            imp_A(x1,x2) = x2
            T_A() = 59
            if_A(x1,x2,x3) = x2 + x3
            F_A() = 32
            eq_A(x1,x2) = 32
            eqt_A(x1,x2) = x1 + x2 + 1
            a_A() = 6
            lock_A() = 28
            cons_A(x1,x2) = x1 + 25
            excl_A() = 17
            ok_A() = 16
            release_A() = 15
            pid_A(x1) = x1 + 15
            false_A() = 6
            locker_A() = 13
            pending_A() = 4
            request_A() = 13
            resource_A() = 13
            tag_A() = 4
            true_A() = 13
            undefined_A() = 5
            tuple_A(x1,x2) = 3
            tuplenil_A(x1) = 14
            int_A(x1) = 6
            locker2_check_available_A(x1,x2) = 6
            nil_A() = 2
            locker2_adduniq_A(x1,x2) = x2
            eqs#!_A(x1,x2) = 29
            stack!_A(x1,x2) = 28
            imp!_A(x1,x2) = 59
            T!_A() = 58
            if!_A(x1,x2,x3) = x1 + x2 + x3
            F!_A() = 33
            eq!_A(x1,x2) = x1 + x2
            eqt!_A(x1,x2) = x2 + 29
            a!_A() = 34
            lock!_A() = 87
            cons!_A(x1,x2) = 37
            excl!_A() = 88
            ok!_A() = 0
            release!_A() = 34
            pid!_A(x1) = 28
            false!_A() = 34
            locker!_A() = 0
            pending!_A() = 59
            request!_A() = 59
            resource!_A() = 89
            tag!_A() = 59
            true!_A() = 60
            undefined!_A() = 34
            tuple!_A(x1,x2) = x2 + 47
            tuplenil!_A(x1) = 36
            int!_A(x1) = x1
            locker2_check_available!_A(x1,x2) = 58
            nil!_A() = 61
            locker2_adduniq!_A(x1,x2) = x1 + x2
  
    partial status:
  
      pi(eqs#) = []
      pi(stack) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(eq) = [2]
      pi(eqt) = [2]
      pi(a) = []
      pi(lock) = []
      pi(cons) = []
      pi(excl) = []
      pi(ok) = []
      pi(release) = []
      pi(pid) = []
      pi(false) = []
      pi(locker) = []
      pi(pending) = []
      pi(request) = []
      pi(resource) = []
      pi(tag) = []
      pi(true) = []
      pi(undefined) = []
      pi(tuple) = []
      pi(tuplenil) = []
      pi(int) = []
      pi(locker2_check_available) = []
      pi(nil) = []
      pi(locker2_adduniq) = [2]

The following rules are removed:

  p1

Then no dependency pair remains.

-- Reduction pair.

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

p1: eqt#(pid(N1),pid(N2)) -> eqt#(N1,N2)
p2: eqt#(tuplenil(H1),tuplenil(H2)) -> eqt#(H1,H2)
p3: eqt#(tuple(H1,T1),tuple(H2,T2)) -> eqt#(T1,T2)
p4: eqt#(tuple(H1,T1),tuple(H2,T2)) -> eqt#(H1,H2)
p5: eqt#(cons(H1,T1),cons(H2,T2)) -> eqt#(T1,T2)
p6: eqt#(cons(H1,T1),cons(H2,T2)) -> eqt#(H1,H2)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r7, r8, r9, r10, r13, r14, r334, r348, r372, r373

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          eqt#_A(x1,x2) = x1 + x2 + 41
          pid_A(x1) = x1 + 13
          tuplenil_A(x1) = x1 + 40
          tuple_A(x1,x2) = x1 + x2 + 42
          cons_A(x1,x2) = x1 + x2 + 13
          and_A(x1,x2) = 3
          F_A() = 2
          imp_A(x1,x2) = x2 + 11
          T_A() = 10
          if_A(x1,x2,x3) = x2 + x3 + 1
          case1_A(x1,x2,x3,x4) = x1 + x2 + x3 + 17
          false_A() = 4
          locker2_adduniq_A(x1,x2) = x2 + 1
          nil_A() = 3
          eqc_A(x1,x2) = x1 + 14
          nocalls_A() = 12
          calls_A(x1,x2,x3) = x1 + x2 + 13
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            eqt#_A(x1,x2) = 0
            pid_A(x1) = x1 + 3
            tuplenil_A(x1) = x1 + 4
            tuple_A(x1,x2) = x1 + x2 + 14
            cons_A(x1,x2) = x1 + x2 + 3
            and_A(x1,x2) = 23
            F_A() = 22
            imp_A(x1,x2) = x2 + 23
            T_A() = 23
            if_A(x1,x2,x3) = x2 + x3
            case1_A(x1,x2,x3,x4) = x3 + 1
            false_A() = 11
            locker2_adduniq_A(x1,x2) = x2
            nil_A() = 3
            eqc_A(x1,x2) = 22
            nocalls_A() = 1
            calls_A(x1,x2,x3) = 2
            eqt#!_A(x1,x2) = 16
            pid!_A(x1) = 5
            tuplenil!_A(x1) = x1 + 5
            tuple!_A(x1,x2) = 13
            cons!_A(x1,x2) = x1 + 15
            and!_A(x1,x2) = x1 + 7
            F!_A() = 4
            imp!_A(x1,x2) = 7
            T!_A() = 6
            if!_A(x1,x2,x3) = x1 + x2 + x3
            case1!_A(x1,x2,x3,x4) = x3 + x4 + 10
            false!_A() = 18
            locker2_adduniq!_A(x1,x2) = x1 + x2
            nil!_A() = 11
            eqc!_A(x1,x2) = 9
            nocalls!_A() = 9
            calls!_A(x1,x2,x3) = 8
  
    partial status:
  
      pi(eqt#) = [1, 2]
      pi(pid) = [1]
      pi(tuplenil) = []
      pi(tuple) = []
      pi(cons) = []
      pi(and) = []
      pi(F) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(case1) = [1, 2, 3]
      pi(false) = []
      pi(locker2_adduniq) = [2]
      pi(nil) = []
      pi(eqc) = [1]
      pi(nocalls) = []
      pi(calls) = []

The following rules are removed:

  p1, p2, p3, p4, p5, p6

Then no dependency pair remains.

-- Reduction pair.

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

p1: element#(int(s(s(N1))),tuple(T1,T2)) -> element#(int(s(N1)),T2)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r9, r13, r14, r18, r19, r27, r36, r39, r56, r58, r59, r67, r76, r78, r79, r82, r87, r96, r98, r99, r102, r107, r116, r117, r120, r128, r140, r148, r159, r162, r170, r181, r182, r185, r190, r199, r202, r210, r222, r233, r242, r245, r253, r262, r264, r265, r266, r269, r277, r289, r297, r306, r308, r309, r312, r348, r349, r352

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          element#_A(x1,x2) = 16
          int_A(x1) = 30
          s_A(x1) = x1 + 32
          tuple_A(x1,x2) = 17
          imp_A(x1,x2) = x2 + 13
          T_A() = 12
          if_A(x1,x2,x3) = x2 + x3 + 1
          F_A() = 32
          eq_A(x1,x2) = x1 + 1
          eqt_A(x1,x2) = x1 + x2 + 1
          nil_A() = 2
          undefined_A() = 30
          a_A() = 15
          excl_A() = 33
          resource_A() = 33
          true_A() = 3
          lock_A() = 41
          cons_A(x1,x2) = 7
          locker_A() = 33
          mcrlrecord_A() = 15
          ok_A() = 27
          pending_A() = 2
          release_A() = 27
          request_A() = 13
          tag_A() = 5
          pid_A(x1) = x1 + 25
          tuplenil_A(x1) = 34
          locker2_adduniq_A(x1,x2) = x2 + 1
          append_A(x1,x2) = 8
          delete_A(x1,x2) = 8
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            element#_A(x1,x2) = x2
            int_A(x1) = 18
            s_A(x1) = 3
            tuple_A(x1,x2) = x1 + x2 + 17
            imp_A(x1,x2) = x2
            T_A() = 22
            if_A(x1,x2,x3) = x2 + x3
            F_A() = 21
            eq_A(x1,x2) = 21
            eqt_A(x1,x2) = x2 + 1
            nil_A() = 2
            undefined_A() = 20
            a_A() = 17
            excl_A() = 20
            resource_A() = 20
            true_A() = 20
            lock_A() = 19
            cons_A(x1,x2) = x1 + x2 + 20
            locker_A() = 16
            mcrlrecord_A() = 16
            ok_A() = 17
            pending_A() = 17
            release_A() = 19
            request_A() = 17
            tag_A() = 17
            pid_A(x1) = x1 + 18
            tuplenil_A(x1) = 17
            locker2_adduniq_A(x1,x2) = x2
            append_A(x1,x2) = x1 + x2 + 1
            delete_A(x1,x2) = x1 + 41
            element#!_A(x1,x2) = x2 + 71
            int!_A(x1) = 72
            s!_A(x1) = x1 + 70
            tuple!_A(x1,x2) = 72
            imp!_A(x1,x2) = 74
            T!_A() = 73
            if!_A(x1,x2,x3) = x1 + x2 + x3
            F!_A() = 72
            eq!_A(x1,x2) = x2 + 49
            eqt!_A(x1,x2) = x1 + 55
            nil!_A() = 80
            undefined!_A() = 0
            a!_A() = 74
            excl!_A() = 82
            resource!_A() = 74
            true!_A() = 98
            lock!_A() = 99
            cons!_A(x1,x2) = 70
            locker!_A() = 74
            mcrlrecord!_A() = 70
            ok!_A() = 73
            pending!_A() = 69
            release!_A() = 73
            request!_A() = 74
            tag!_A() = 71
            pid!_A(x1) = 54
            tuplenil!_A(x1) = 80
            locker2_adduniq!_A(x1,x2) = x1 + x2
            append!_A(x1,x2) = x1 + 71
            delete!_A(x1,x2) = x2 + 49
  
    partial status:
  
      pi(element#) = []
      pi(int) = []
      pi(s) = [1]
      pi(tuple) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(eq) = [1]
      pi(eqt) = [1, 2]
      pi(nil) = []
      pi(undefined) = []
      pi(a) = []
      pi(excl) = []
      pi(resource) = []
      pi(true) = []
      pi(lock) = []
      pi(cons) = []
      pi(locker) = []
      pi(mcrlrecord) = []
      pi(ok) = []
      pi(pending) = []
      pi(release) = []
      pi(request) = []
      pi(tag) = []
      pi(pid) = [1]
      pi(tuplenil) = []
      pi(locker2_adduniq) = [2]
      pi(append) = []
      pi(delete) = []

The following rules are removed:

  p1

Then no dependency pair remains.

-- Reduction pair.

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

p1: record_updates#(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates#(record_update(Record,Name,Field,NewF),Name,Fields)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r9, r13, r14, r52, r61, r121, r123, r133, r149, r153, r155, r209, r210, r211, r215, r216, r217, r218, r223, r225, r238, r282, r348

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          record_updates#_A(x1,x2,x3) = 19
          cons_A(x1,x2) = 7
          tuple_A(x1,x2) = x2 + 4
          tuplenil_A(x1) = 14
          record_update_A(x1,x2,x3,x4) = x1
          imp_A(x1,x2) = x2 + 2
          T_A() = 1
          if_A(x1,x2,x3) = x2 + x3 + 1
          F_A() = 13
          eqt_A(x1,x2) = x2 + 8
          excl_A() = 6
          ok_A() = 6
          false_A() = 67
          int_A(x1) = x1 + 14
          pid_A(x1) = x1 + 14
          pending_A() = 34
          release_A() = 14
          request_A() = 5
          true_A() = 4
          a_A() = 14
          locker2_adduniq_A(x1,x2) = x2 + 1
          nil_A() = 3
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            record_updates#_A(x1,x2,x3) = 0
            cons_A(x1,x2) = x1 + x2 + 16
            tuple_A(x1,x2) = x2 + 4
            tuplenil_A(x1) = x1
            record_update_A(x1,x2,x3,x4) = x1 + x3 + 1
            imp_A(x1,x2) = x2
            T_A() = 75
            if_A(x1,x2,x3) = x2 + x3
            F_A() = 66
            eqt_A(x1,x2) = x1 + x2 + 28
            excl_A() = 16
            ok_A() = 34
            false_A() = 21
            int_A(x1) = 1
            pid_A(x1) = x1 + 16
            pending_A() = 16
            release_A() = 17
            request_A() = 15
            true_A() = 23
            a_A() = 16
            locker2_adduniq_A(x1,x2) = x2
            nil_A() = 20
            record_updates#!_A(x1,x2,x3) = x3 + 174
            cons!_A(x1,x2) = x1 + x2 + 109
            tuple!_A(x1,x2) = 173
            tuplenil!_A(x1) = x1 + 66
            record_update!_A(x1,x2,x3,x4) = x4 + 195
            imp!_A(x1,x2) = 54
            T!_A() = 53
            if!_A(x1,x2,x3) = x1 + x2 + x3
            F!_A() = 66
            eqt!_A(x1,x2) = x2 + 51
            excl!_A() = 151
            ok!_A() = 67
            false!_A() = 178
            int!_A(x1) = 173
            pid!_A(x1) = 67
            pending!_A() = 110
            release!_A() = 67
            request!_A() = 54
            true!_A() = 172
            a!_A() = 67
            locker2_adduniq!_A(x1,x2) = x1 + x2
            nil!_A() = 65
  
    partial status:
  
      pi(record_updates#) = []
      pi(cons) = []
      pi(tuple) = [2]
      pi(tuplenil) = []
      pi(record_update) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(eqt) = [2]
      pi(excl) = []
      pi(ok) = []
      pi(false) = []
      pi(int) = [1]
      pi(pid) = [1]
      pi(pending) = []
      pi(release) = []
      pi(request) = []
      pi(true) = []
      pi(a) = []
      pi(locker2_adduniq) = [2]
      pi(nil) = []

The following rules are removed:

  p1

Then no dependency pair remains.

-- Reduction pair.

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

p1: locker2_map_promote_pending#(cons(Lock,Locks),Pending) -> locker2_map_promote_pending#(Locks,Pending)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r9, r13, r14, r30, r32, r50, r52, r70, r72, r92, r110, r112, r131, r133, r151, r153, r155, r173, r175, r193, r195, r213, r215, r236, r256, r258, r280, r282, r300, r302, r337, r348, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          locker2_map_promote_pending#_A(x1,x2) = x1
          cons_A(x1,x2) = x2 + 56
          imp_A(x1,x2) = x2 + 41
          T_A() = 40
          if_A(x1,x2,x3) = x2 + x3 + 1
          F_A() = 6
          eqt_A(x1,x2) = x2 + 2
          a_A() = 41
          locker_A() = 41
          ok_A() = 7
          excl_A() = 47
          lock_A() = 3
          mcrlrecord_A() = 5
          pending_A() = 2
          release_A() = 7
          request_A() = 41
          resource_A() = 117
          tag_A() = 41
          true_A() = 46
          pid_A(x1) = x1 + 7
          int_A(x1) = 37
          tuple_A(x1,x2) = x1 + x2 + 36
          tuplenil_A(x1) = 7
          case4_A(x1,x2,x3) = x3 + 4
          false_A() = 3
          locker2_adduniq_A(x1,x2) = x2 + 1
          nil_A() = 47
          member_A(x1,x2) = x2 + 51
          case9_A(x1,x2,x3,x4) = 47
          equal_A(x1,x2) = 1
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            locker2_map_promote_pending#_A(x1,x2) = x1
            cons_A(x1,x2) = x1 + x2 + 2
            imp_A(x1,x2) = x2
            T_A() = 33
            if_A(x1,x2,x3) = x2 + x3
            F_A() = 32
            eqt_A(x1,x2) = x2 + 1
            a_A() = 1
            locker_A() = 31
            ok_A() = 31
            excl_A() = 17
            lock_A() = 1
            mcrlrecord_A() = 1
            pending_A() = 30
            release_A() = 1
            request_A() = 1
            resource_A() = 1
            tag_A() = 30
            true_A() = 2
            pid_A(x1) = x1 + 1
            int_A(x1) = 1
            tuple_A(x1,x2) = 13
            tuplenil_A(x1) = 14
            case4_A(x1,x2,x3) = 2
            false_A() = 2
            locker2_adduniq_A(x1,x2) = x2
            nil_A() = 10
            member_A(x1,x2) = 1
            case9_A(x1,x2,x3,x4) = 0
            equal_A(x1,x2) = 2
            locker2_map_promote_pending#!_A(x1,x2) = 26
            cons!_A(x1,x2) = x1 + 25
            imp!_A(x1,x2) = 35
            T!_A() = 34
            if!_A(x1,x2,x3) = x1 + x2 + x3
            F!_A() = 31
            eqt!_A(x1,x2) = 31
            a!_A() = 35
            locker!_A() = 35
            ok!_A() = 32
            excl!_A() = 0
            lock!_A() = 25
            mcrlrecord!_A() = 37
            pending!_A() = 38
            release!_A() = 0
            request!_A() = 32
            resource!_A() = 38
            tag!_A() = 35
            true!_A() = 39
            pid!_A(x1) = 32
            int!_A(x1) = 37
            tuple!_A(x1,x2) = 36
            tuplenil!_A(x1) = 30
            case4!_A(x1,x2,x3) = 33
            false!_A() = 32
            locker2_adduniq!_A(x1,x2) = x1 + x2
            nil!_A() = 25
            member!_A(x1,x2) = x1 + x2 + 23
            case9!_A(x1,x2,x3,x4) = 40
            equal!_A(x1,x2) = 25
  
    partial status:
  
      pi(locker2_map_promote_pending#) = [1]
      pi(cons) = [2]
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(eqt) = [2]
      pi(a) = []
      pi(locker) = []
      pi(ok) = []
      pi(excl) = []
      pi(lock) = []
      pi(mcrlrecord) = []
      pi(pending) = []
      pi(release) = []
      pi(request) = []
      pi(resource) = []
      pi(tag) = []
      pi(true) = []
      pi(pid) = [1]
      pi(int) = []
      pi(tuple) = []
      pi(tuplenil) = []
      pi(case4) = [3]
      pi(false) = []
      pi(locker2_adduniq) = [2]
      pi(nil) = []
      pi(member) = []
      pi(case9) = []
      pi(equal) = []

The following rules are removed:

  p1

Then no dependency pair remains.

-- Reduction pair.

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

p1: locker2_map_claim_lock#(cons(Lock,Locks),Resources,Client) -> locker2_map_claim_lock#(Locks,Resources,Client)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r9, r13, r14, r19, r20, r21, r22, r23, r24, r27, r29, r30, r32, r33, r34, r35, r36, r39, r40, r41, r42, r43, r44, r46, r49, r50, r52, r53, r54, r55, r56, r59, r60, r61, r62, r63, r64, r66, r67, r70, r72, r73, r74, r75, r76, r79, r80, r81, r82, r83, r84, r86, r87, r89, r92, r93, r94, r95, r96, r99, r100, r101, r102, r103, r104, r106, r107, r109, r110, r112, r113, r114, r115, r116, r117, r120, r121, r122, r123, r124, r125, r127, r130, r131, r133, r135, r136, r137, r140, r141, r144, r145, r147, r148, r150, r151, r153, r155, r156, r157, r159, r162, r163, r164, r165, r166, r167, r169, r170, r172, r173, r175, r176, r177, r178, r182, r183, r184, r185, r186, r187, r189, r190, r192, r193, r195, r196, r197, r198, r199, r202, r203, r205, r206, r207, r209, r210, r212, r213, r215, r216, r217, r218, r219, r222, r223, r224, r225, r226, r227, r229, r230, r232, r233, r235, r236, r238, r239, r240, r241, r242, r245, r247, r248, r250, r252, r253, r255, r256, r258, r260, r261, r262, r265, r266, r269, r270, r273, r274, r276, r277, r279, r280, r282, r283, r284, r285, r286, r289, r292, r294, r296, r297, r299, r300, r302, r303, r304, r305, r306, r308, r309, r310, r311, r312, r313, r348, r349, r353, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          locker2_map_claim_lock#_A(x1,x2,x3) = 1
          cons_A(x1,x2) = 5
          imp_A(x1,x2) = x2 + 3
          T_A() = 2
          if_A(x1,x2,x3) = x2 + x3 + 1
          F_A() = 21
          eqt_A(x1,x2) = x1 + x2 + 11
          nil_A() = 54
          undefined_A() = 22
          pid_A(x1) = x1 + 10
          int_A(x1) = 1
          tuple_A(x1,x2) = x1 + x2 + 8
          tuplenil_A(x1) = 22
          a_A() = 22
          excl_A() = 22
          lock_A() = 222
          locker_A() = 22
          ok_A() = 22
          pending_A() = 3
          release_A() = 22
          request_A() = 22
          resource_A() = 226
          false_A() = 6
          mcrlrecord_A() = 225
          tag_A() = 22
          true_A() = 221
          locker2_adduniq_A(x1,x2) = x2 + 1
          append_A(x1,x2) = 6
          delete_A(x1,x2) = 55
          case8_A(x1,x2,x3,x4) = 6
          equal_A(x1,x2) = x2 + 56
          member_A(x1,x2) = x1 + 228
          case9_A(x1,x2,x3,x4) = 222
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            locker2_map_claim_lock#_A(x1,x2,x3) = x1
            cons_A(x1,x2) = x1 + x2 + 45
            imp_A(x1,x2) = x2
            T_A() = 47
            if_A(x1,x2,x3) = x2 + x3
            F_A() = 13
            eqt_A(x1,x2) = x2 + 1
            nil_A() = 20
            undefined_A() = 41
            pid_A(x1) = x1 + 43
            int_A(x1) = 43
            tuple_A(x1,x2) = 12
            tuplenil_A(x1) = 45
            a_A() = 41
            excl_A() = 45
            lock_A() = 45
            locker_A() = 43
            ok_A() = 16
            pending_A() = 37
            release_A() = 43
            request_A() = 44
            resource_A() = 45
            false_A() = 18
            mcrlrecord_A() = 14
            tag_A() = 43
            true_A() = 39
            locker2_adduniq_A(x1,x2) = x2
            append_A(x1,x2) = x1 + 1
            delete_A(x1,x2) = x1 + 1
            case8_A(x1,x2,x3,x4) = 0
            equal_A(x1,x2) = 2
            member_A(x1,x2) = 1
            case9_A(x1,x2,x3,x4) = 0
            locker2_map_claim_lock#!_A(x1,x2,x3) = x1 + 68
            cons!_A(x1,x2) = x1 + 67
            imp!_A(x1,x2) = 0
            T!_A() = 60
            if!_A(x1,x2,x3) = x1 + x2 + x3
            F!_A() = 61
            eqt!_A(x1,x2) = x1 + x2 + 5
            nil!_A() = 76
            undefined!_A() = 62
            pid!_A(x1) = 6
            int!_A(x1) = 61
            tuple!_A(x1,x2) = 4
            tuplenil!_A(x1) = x1 + 62
            a!_A() = 59
            excl!_A() = 2
            lock!_A() = 63
            locker!_A() = 62
            ok!_A() = 62
            pending!_A() = 3
            release!_A() = 62
            request!_A() = 62
            resource!_A() = 85
            false!_A() = 60
            mcrlrecord!_A() = 84
            tag!_A() = 62
            true!_A() = 84
            locker2_adduniq!_A(x1,x2) = x1 + x2
            append!_A(x1,x2) = 68
            delete!_A(x1,x2) = x2 + 20
            case8!_A(x1,x2,x3,x4) = 66
            equal!_A(x1,x2) = x1 + 58
            member!_A(x1,x2) = x2 + 39
            case9!_A(x1,x2,x3,x4) = 84
  
    partial status:
  
      pi(locker2_map_claim_lock#) = []
      pi(cons) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(eqt) = [1, 2]
      pi(nil) = []
      pi(undefined) = []
      pi(pid) = [1]
      pi(int) = []
      pi(tuple) = []
      pi(tuplenil) = []
      pi(a) = []
      pi(excl) = []
      pi(lock) = []
      pi(locker) = []
      pi(ok) = []
      pi(pending) = []
      pi(release) = []
      pi(request) = []
      pi(resource) = []
      pi(false) = []
      pi(mcrlrecord) = []
      pi(tag) = []
      pi(true) = []
      pi(locker2_adduniq) = [2]
      pi(append) = []
      pi(delete) = []
      pi(case8) = []
      pi(equal) = []
      pi(member) = []
      pi(case9) = []

The following rules are removed:

  p1

Then no dependency pair remains.

-- Reduction pair.

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

p1: subtract#(List,cons(Head,Tail)) -> subtract#(delete(Head,List),Tail)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r9, r13, r14, r348, r352, r353

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          subtract#_A(x1,x2) = x1 + x2 + 6
          cons_A(x1,x2) = x2 + 76
          delete_A(x1,x2) = x2 + 71
          imp_A(x1,x2) = x2 + 2
          T_A() = 1
          if_A(x1,x2,x3) = x2 + x3 + 1
          F_A() = 150
          locker2_adduniq_A(x1,x2) = x2 + 1
          nil_A() = 6
          case8_A(x1,x2,x3,x4) = 1
          equal_A(x1,x2) = x1 + 41
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            subtract#_A(x1,x2) = x1 + x2
            cons_A(x1,x2) = x1 + x2 + 33
            delete_A(x1,x2) = 33
            imp_A(x1,x2) = x2
            T_A() = 2
            if_A(x1,x2,x3) = x2 + x3
            F_A() = 3
            locker2_adduniq_A(x1,x2) = x2
            nil_A() = 4
            case8_A(x1,x2,x3,x4) = 0
            equal_A(x1,x2) = 2
            subtract#!_A(x1,x2) = x1 + x2 + 9
            cons!_A(x1,x2) = x1 + x2 + 6
            delete!_A(x1,x2) = 41
            imp!_A(x1,x2) = 2
            T!_A() = 1
            if!_A(x1,x2,x3) = x1 + x2 + x3
            F!_A() = 53
            locker2_adduniq!_A(x1,x2) = x1 + x2
            nil!_A() = 39
            case8!_A(x1,x2,x3,x4) = 42
            equal!_A(x1,x2) = 69
  
    partial status:
  
      pi(subtract#) = []
      pi(cons) = []
      pi(delete) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(locker2_adduniq) = [2]
      pi(nil) = []
      pi(case8) = []
      pi(equal) = []

The following rules are removed:

  p1

Then no dependency pair remains.

-- Reduction pair.

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

p1: locker2_check_availables#(cons(Resource,Resources),Locks) -> locker2_check_availables#(Resources,Locks)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r9, r13, r14, r339, r344, r348, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          locker2_check_availables#_A(x1,x2) = x1
          cons_A(x1,x2) = x2 + 16
          imp_A(x1,x2) = x2 + 24
          T_A() = 23
          if_A(x1,x2,x3) = x2 + x3 + 1
          F_A() = 49
          locker2_obtainables_A(x1,x2) = x2 + 53
          case5_A(x1,x2,x3,x4) = x4
          member_A(x1,x2) = x2 + 38
          record_extract_A(x1,x2,x3) = x3
          lock_A() = 51
          pending_A() = 6
          case6_A(x1,x2,x3,x4) = x2 + x3 + 19
          true_A() = 52
          andt_A(x1,x2) = x1 + x2
          equal_A(x1,x2) = 9
          excl_A() = 20
          nil_A() = 18
          locker2_adduniq_A(x1,x2) = x2 + 1
          case9_A(x1,x2,x3,x4) = x1 + 53
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            locker2_check_availables#_A(x1,x2) = 0
            cons_A(x1,x2) = x1 + 16
            imp_A(x1,x2) = x2
            T_A() = 7
            if_A(x1,x2,x3) = x2 + x3
            F_A() = 8
            locker2_obtainables_A(x1,x2) = 1
            case5_A(x1,x2,x3,x4) = 0
            member_A(x1,x2) = 6
            record_extract_A(x1,x2,x3) = 1
            lock_A() = 1
            pending_A() = 5
            case6_A(x1,x2,x3,x4) = 2
            true_A() = 6
            andt_A(x1,x2) = 2
            equal_A(x1,x2) = 2
            excl_A() = 6
            nil_A() = 27
            locker2_adduniq_A(x1,x2) = x2
            case9_A(x1,x2,x3,x4) = 5
            locker2_check_availables#!_A(x1,x2) = 15
            cons!_A(x1,x2) = 14
            imp!_A(x1,x2) = 34
            T!_A() = 33
            if!_A(x1,x2,x3) = x1 + x2 + x3
            F!_A() = 36
            locker2_obtainables!_A(x1,x2) = 13
            case5!_A(x1,x2,x3,x4) = 13
            member!_A(x1,x2) = x2 + 11
            record_extract!_A(x1,x2,x3) = x1 + 46
            lock!_A() = 44
            pending!_A() = 15
            case6!_A(x1,x2,x3,x4) = 55
            true!_A() = 29
            andt!_A(x1,x2) = 56
            equal!_A(x1,x2) = 28
            excl!_A() = 56
            nil!_A() = 28
            locker2_adduniq!_A(x1,x2) = x1 + x2
            case9!_A(x1,x2,x3,x4) = 26
  
    partial status:
  
      pi(locker2_check_availables#) = []
      pi(cons) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(locker2_obtainables) = []
      pi(case5) = []
      pi(member) = [2]
      pi(record_extract) = []
      pi(lock) = []
      pi(pending) = []
      pi(case6) = [3]
      pi(true) = []
      pi(andt) = [1, 2]
      pi(equal) = []
      pi(excl) = []
      pi(nil) = []
      pi(locker2_adduniq) = [2]
      pi(case9) = [1]

The following rules are removed:

  p1

Then no dependency pair remains.

-- Reduction pair.

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

p1: append#(cons(Head,Tail),List) -> append#(Tail,List)

and R consists of:

r1: or(T(),T()) -> T()
r2: or(F(),T()) -> T()
r3: or(T(),F()) -> T()
r4: or(F(),F()) -> F()
r5: and(T(),B) -> B
r6: and(B,T()) -> B
r7: and(F(),B) -> F()
r8: and(B,F()) -> F()
r9: imp(T(),B) -> B
r10: imp(F(),B) -> T()
r11: not(T()) -> F()
r12: not(F()) -> T()
r13: if(T(),B1,B2) -> B1
r14: if(F(),B1,B2) -> B2
r15: eq(T(),T()) -> T()
r16: eq(F(),F()) -> T()
r17: eq(T(),F()) -> F()
r18: eq(F(),T()) -> F()
r19: eqt(nil(),undefined()) -> F()
r20: eqt(nil(),pid(N2)) -> F()
r21: eqt(nil(),int(N2)) -> F()
r22: eqt(nil(),cons(H2,T2)) -> F()
r23: eqt(nil(),tuple(H2,T2)) -> F()
r24: eqt(nil(),tuplenil(H2)) -> F()
r25: eqt(a(),nil()) -> F()
r26: eqt(a(),a()) -> T()
r27: eqt(a(),excl()) -> F()
r28: eqt(a(),false()) -> F()
r29: eqt(a(),lock()) -> F()
r30: eqt(a(),locker()) -> F()
r31: eqt(a(),mcrlrecord()) -> F()
r32: eqt(a(),ok()) -> F()
r33: eqt(a(),pending()) -> F()
r34: eqt(a(),release()) -> F()
r35: eqt(a(),request()) -> F()
r36: eqt(a(),resource()) -> F()
r37: eqt(a(),tag()) -> F()
r38: eqt(a(),true()) -> F()
r39: eqt(a(),undefined()) -> F()
r40: eqt(a(),pid(N2)) -> F()
r41: eqt(a(),int(N2)) -> F()
r42: eqt(a(),cons(H2,T2)) -> F()
r43: eqt(a(),tuple(H2,T2)) -> F()
r44: eqt(a(),tuplenil(H2)) -> F()
r45: eqt(excl(),nil()) -> F()
r46: eqt(excl(),a()) -> F()
r47: eqt(excl(),excl()) -> T()
r48: eqt(excl(),false()) -> F()
r49: eqt(excl(),lock()) -> F()
r50: eqt(excl(),locker()) -> F()
r51: eqt(excl(),mcrlrecord()) -> F()
r52: eqt(excl(),ok()) -> F()
r53: eqt(excl(),pending()) -> F()
r54: eqt(excl(),release()) -> F()
r55: eqt(excl(),request()) -> F()
r56: eqt(excl(),resource()) -> F()
r57: eqt(excl(),tag()) -> F()
r58: eqt(excl(),true()) -> F()
r59: eqt(excl(),undefined()) -> F()
r60: eqt(excl(),pid(N2)) -> F()
r61: eqt(excl(),eqt(false(),int(N2))) -> F()
r62: eqt(false(),cons(H2,T2)) -> F()
r63: eqt(false(),tuple(H2,T2)) -> F()
r64: eqt(false(),tuplenil(H2)) -> F()
r65: eqt(lock(),nil()) -> F()
r66: eqt(lock(),a()) -> F()
r67: eqt(lock(),excl()) -> F()
r68: eqt(lock(),false()) -> F()
r69: eqt(lock(),lock()) -> T()
r70: eqt(lock(),locker()) -> F()
r71: eqt(lock(),mcrlrecord()) -> F()
r72: eqt(lock(),ok()) -> F()
r73: eqt(lock(),pending()) -> F()
r74: eqt(lock(),release()) -> F()
r75: eqt(lock(),request()) -> F()
r76: eqt(lock(),resource()) -> F()
r77: eqt(lock(),tag()) -> F()
r78: eqt(lock(),true()) -> F()
r79: eqt(lock(),undefined()) -> F()
r80: eqt(lock(),pid(N2)) -> F()
r81: eqt(lock(),int(N2)) -> F()
r82: eqt(lock(),cons(H2,T2)) -> F()
r83: eqt(lock(),tuple(H2,T2)) -> F()
r84: eqt(lock(),tuplenil(H2)) -> F()
r85: eqt(locker(),nil()) -> F()
r86: eqt(locker(),a()) -> F()
r87: eqt(locker(),excl()) -> F()
r88: eqt(locker(),false()) -> F()
r89: eqt(locker(),lock()) -> F()
r90: eqt(locker(),locker()) -> T()
r91: eqt(locker(),mcrlrecord()) -> F()
r92: eqt(locker(),ok()) -> F()
r93: eqt(locker(),pending()) -> F()
r94: eqt(locker(),release()) -> F()
r95: eqt(locker(),request()) -> F()
r96: eqt(locker(),resource()) -> F()
r97: eqt(locker(),tag()) -> F()
r98: eqt(locker(),true()) -> F()
r99: eqt(locker(),undefined()) -> F()
r100: eqt(locker(),pid(N2)) -> F()
r101: eqt(locker(),int(N2)) -> F()
r102: eqt(locker(),cons(H2,T2)) -> F()
r103: eqt(locker(),tuple(H2,T2)) -> F()
r104: eqt(locker(),tuplenil(H2)) -> F()
r105: eqt(mcrlrecord(),nil()) -> F()
r106: eqt(mcrlrecord(),a()) -> F()
r107: eqt(mcrlrecord(),excl()) -> F()
r108: eqt(mcrlrecord(),false()) -> F()
r109: eqt(mcrlrecord(),lock()) -> F()
r110: eqt(mcrlrecord(),locker()) -> F()
r111: eqt(mcrlrecord(),mcrlrecord()) -> T()
r112: eqt(mcrlrecord(),ok()) -> F()
r113: eqt(mcrlrecord(),pending()) -> F()
r114: eqt(mcrlrecord(),release()) -> F()
r115: eqt(mcrlrecord(),request()) -> F()
r116: eqt(mcrlrecord(),resource()) -> F()
r117: eqt(ok(),resource()) -> F()
r118: eqt(ok(),tag()) -> F()
r119: eqt(ok(),true()) -> F()
r120: eqt(ok(),undefined()) -> F()
r121: eqt(ok(),pid(N2)) -> F()
r122: eqt(ok(),int(N2)) -> F()
r123: eqt(ok(),cons(H2,T2)) -> F()
r124: eqt(ok(),tuple(H2,T2)) -> F()
r125: eqt(ok(),tuplenil(H2)) -> F()
r126: eqt(pending(),nil()) -> F()
r127: eqt(pending(),a()) -> F()
r128: eqt(pending(),excl()) -> F()
r129: eqt(pending(),false()) -> F()
r130: eqt(pending(),lock()) -> F()
r131: eqt(pending(),locker()) -> F()
r132: eqt(pending(),mcrlrecord()) -> F()
r133: eqt(pending(),ok()) -> F()
r134: eqt(pending(),pending()) -> T()
r135: eqt(pending(),release()) -> F()
r136: eqt(pending(),request()) -> F()
r137: eqt(pending(),resource()) -> F()
r138: eqt(pending(),tag()) -> F()
r139: eqt(pending(),true()) -> F()
r140: eqt(pending(),undefined()) -> F()
r141: eqt(pending(),pid(N2)) -> F()
r142: eqt(pending(),int(N2)) -> F()
r143: eqt(pending(),cons(H2,T2)) -> F()
r144: eqt(pending(),tuple(H2,T2)) -> F()
r145: eqt(pending(),tuplenil(H2)) -> F()
r146: eqt(release(),nil()) -> F()
r147: eqt(release(),a()) -> F()
r148: eqt(release(),excl()) -> F()
r149: eqt(release(),false()) -> F()
r150: eqt(release(),lock()) -> F()
r151: eqt(release(),locker()) -> F()
r152: eqt(release(),mcrlrecord()) -> F()
r153: eqt(release(),ok()) -> F()
r154: eqt(request(),mcrlrecord()) -> F()
r155: eqt(request(),ok()) -> F()
r156: eqt(request(),pending()) -> F()
r157: eqt(request(),release()) -> F()
r158: eqt(request(),request()) -> T()
r159: eqt(request(),resource()) -> F()
r160: eqt(request(),tag()) -> F()
r161: eqt(request(),true()) -> F()
r162: eqt(request(),undefined()) -> F()
r163: eqt(request(),pid(N2)) -> F()
r164: eqt(request(),int(N2)) -> F()
r165: eqt(request(),cons(H2,T2)) -> F()
r166: eqt(request(),tuple(H2,T2)) -> F()
r167: eqt(request(),tuplenil(H2)) -> F()
r168: eqt(resource(),nil()) -> F()
r169: eqt(resource(),a()) -> F()
r170: eqt(resource(),excl()) -> F()
r171: eqt(resource(),false()) -> F()
r172: eqt(resource(),lock()) -> F()
r173: eqt(resource(),locker()) -> F()
r174: eqt(resource(),mcrlrecord()) -> F()
r175: eqt(resource(),ok()) -> F()
r176: eqt(resource(),pending()) -> F()
r177: eqt(resource(),release()) -> F()
r178: eqt(resource(),request()) -> F()
r179: eqt(resource(),resource()) -> T()
r180: eqt(resource(),tag()) -> F()
r181: eqt(resource(),true()) -> F()
r182: eqt(resource(),undefined()) -> F()
r183: eqt(resource(),pid(N2)) -> F()
r184: eqt(resource(),int(N2)) -> F()
r185: eqt(resource(),cons(H2,T2)) -> F()
r186: eqt(resource(),tuple(H2,T2)) -> F()
r187: eqt(resource(),tuplenil(H2)) -> F()
r188: eqt(tag(),nil()) -> F()
r189: eqt(tag(),a()) -> F()
r190: eqt(tag(),excl()) -> F()
r191: eqt(tag(),false()) -> F()
r192: eqt(tag(),lock()) -> F()
r193: eqt(tag(),locker()) -> F()
r194: eqt(tag(),mcrlrecord()) -> F()
r195: eqt(tag(),ok()) -> F()
r196: eqt(tag(),pending()) -> F()
r197: eqt(tag(),release()) -> F()
r198: eqt(tag(),request()) -> F()
r199: eqt(tag(),resource()) -> F()
r200: eqt(tag(),tag()) -> T()
r201: eqt(tag(),true()) -> F()
r202: eqt(tag(),undefined()) -> F()
r203: eqt(tag(),pid(N2)) -> F()
r204: eqt(tag(),int(N2)) -> F()
r205: eqt(tag(),cons(H2,T2)) -> F()
r206: eqt(tag(),tuple(H2,T2)) -> F()
r207: eqt(tag(),tuplenil(H2)) -> F()
r208: eqt(true(),nil()) -> F()
r209: eqt(true(),a()) -> F()
r210: eqt(true(),excl()) -> F()
r211: eqt(true(),false()) -> F()
r212: eqt(true(),lock()) -> F()
r213: eqt(true(),locker()) -> F()
r214: eqt(true(),mcrlrecord()) -> F()
r215: eqt(true(),ok()) -> F()
r216: eqt(true(),pending()) -> F()
r217: eqt(true(),release()) -> F()
r218: eqt(true(),request()) -> F()
r219: eqt(true(),resource()) -> F()
r220: eqt(true(),tag()) -> F()
r221: eqt(true(),true()) -> T()
r222: eqt(true(),undefined()) -> F()
r223: eqt(true(),pid(N2)) -> F()
r224: eqt(true(),int(N2)) -> F()
r225: eqt(true(),cons(H2,T2)) -> F()
r226: eqt(true(),tuple(H2,T2)) -> F()
r227: eqt(true(),tuplenil(H2)) -> F()
r228: eqt(undefined(),nil()) -> F()
r229: eqt(undefined(),a()) -> F()
r230: eqt(undefined(),tuplenil(H2)) -> F()
r231: eqt(pid(N1),nil()) -> F()
r232: eqt(pid(N1),a()) -> F()
r233: eqt(pid(N1),excl()) -> F()
r234: eqt(pid(N1),false()) -> F()
r235: eqt(pid(N1),lock()) -> F()
r236: eqt(pid(N1),locker()) -> F()
r237: eqt(pid(N1),mcrlrecord()) -> F()
r238: eqt(pid(N1),ok()) -> F()
r239: eqt(pid(N1),pending()) -> F()
r240: eqt(pid(N1),release()) -> F()
r241: eqt(pid(N1),request()) -> F()
r242: eqt(pid(N1),resource()) -> F()
r243: eqt(pid(N1),tag()) -> F()
r244: eqt(pid(N1),true()) -> F()
r245: eqt(pid(N1),undefined()) -> F()
r246: eqt(pid(N1),pid(N2)) -> eqt(N1,N2)
r247: eqt(pid(N1),int(N2)) -> F()
r248: eqt(pid(N1),cons(H2,T2)) -> F()
r249: eqt(pid(N1),tuple(H2,T2)) -> F()
r250: eqt(pid(N1),tuplenil(H2)) -> F()
r251: eqt(int(N1),nil()) -> F()
r252: eqt(int(N1),a()) -> F()
r253: eqt(int(N1),excl()) -> F()
r254: eqt(int(N1),false()) -> F()
r255: eqt(int(N1),lock()) -> F()
r256: eqt(int(N1),locker()) -> F()
r257: eqt(int(N1),mcrlrecord()) -> F()
r258: eqt(int(N1),ok()) -> F()
r259: eqt(int(N1),pending()) -> F()
r260: eqt(int(N1),release()) -> F()
r261: eqt(int(N1),request()) -> F()
r262: eqt(int(N1),resource()) -> F()
r263: eqt(int(N1),tag()) -> F()
r264: eqt(int(N1),true()) -> F()
r265: eqt(int(N1),undefined()) -> F()
r266: eqt(cons(H1,T1),resource()) -> F()
r267: eqt(cons(H1,T1),tag()) -> F()
r268: eqt(cons(H1,T1),true()) -> F()
r269: eqt(cons(H1,T1),undefined()) -> F()
r270: eqt(cons(H1,T1),pid(N2)) -> F()
r271: eqt(cons(H1,T1),int(N2)) -> F()
r272: eqt(cons(H1,T1),cons(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r273: eqt(cons(H1,T1),tuple(H2,T2)) -> F()
r274: eqt(cons(H1,T1),tuplenil(H2)) -> F()
r275: eqt(tuple(H1,T1),nil()) -> F()
r276: eqt(tuple(H1,T1),a()) -> F()
r277: eqt(tuple(H1,T1),excl()) -> F()
r278: eqt(tuple(H1,T1),false()) -> F()
r279: eqt(tuple(H1,T1),lock()) -> F()
r280: eqt(tuple(H1,T1),locker()) -> F()
r281: eqt(tuple(H1,T1),mcrlrecord()) -> F()
r282: eqt(tuple(H1,T1),ok()) -> F()
r283: eqt(tuple(H1,T1),pending()) -> F()
r284: eqt(tuple(H1,T1),release()) -> F()
r285: eqt(tuple(H1,T1),request()) -> F()
r286: eqt(tuple(H1,T1),resource()) -> F()
r287: eqt(tuple(H1,T1),tag()) -> F()
r288: eqt(tuple(H1,T1),true()) -> F()
r289: eqt(tuple(H1,T1),undefined()) -> F()
r290: eqt(tuple(H1,T1),pid(N2)) -> F()
r291: eqt(tuple(H1,T1),int(N2)) -> F()
r292: eqt(tuple(H1,T1),cons(H2,T2)) -> F()
r293: eqt(tuple(H1,T1),tuple(H2,T2)) -> and(eqt(H1,H2),eqt(T1,T2))
r294: eqt(tuple(H1,T1),tuplenil(H2)) -> F()
r295: eqt(tuplenil(H1),nil()) -> F()
r296: eqt(tuplenil(H1),a()) -> F()
r297: eqt(tuplenil(H1),excl()) -> F()
r298: eqt(tuplenil(H1),false()) -> F()
r299: eqt(tuplenil(H1),lock()) -> F()
r300: eqt(tuplenil(H1),locker()) -> F()
r301: eqt(tuplenil(H1),mcrlrecord()) -> F()
r302: eqt(tuplenil(H1),ok()) -> F()
r303: eqt(tuplenil(H1),pending()) -> F()
r304: eqt(tuplenil(H1),release()) -> F()
r305: eqt(tuplenil(H1),request()) -> F()
r306: eqt(tuplenil(H1),resource()) -> F()
r307: eqt(tuplenil(H1),tag()) -> F()
r308: eqt(tuplenil(H1),true()) -> F()
r309: eqt(tuplenil(H1),undefined()) -> F()
r310: eqt(tuplenil(H1),pid(N2)) -> F()
r311: eqt(tuplenil(H1),int(N2)) -> F()
r312: eqt(tuplenil(H1),cons(H2,T2)) -> F()
r313: eqt(tuplenil(H1),tuple(H2,T2)) -> F()
r314: eqt(tuplenil(H1),tuplenil(H2)) -> eqt(H1,H2)
r315: element(int(s(|0|())),tuplenil(T1)) -> T1
r316: element(int(s(|0|())),tuple(T1,T2)) -> T1
r317: element(int(s(s(N1))),tuple(T1,T2)) -> element(int(s(N1)),T2)
r318: record_new(lock()) -> tuple(mcrlrecord(),tuple(lock(),tuple(undefined(),tuple(nil(),tuplenil(nil())))))
r319: record_extract(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),resource()) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2)))))
r320: record_update(tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(F2))))),lock(),pending(),NewF) -> tuple(mcrlrecord(),tuple(lock(),tuple(F0,tuple(F1,tuplenil(NewF)))))
r321: record_updates(Record,Name,nil()) -> Record
r322: record_updates(Record,Name,cons(tuple(Field,tuplenil(NewF)),Fields)) -> record_updates(record_update(Record,Name,Field,NewF),Name,Fields)
r323: locker2_map_promote_pending(nil(),Pending) -> nil()
r324: locker2_map_promote_pending(cons(Lock,Locks),Pending) -> cons(locker2_promote_pending(Lock,Pending),locker2_map_promote_pending(Locks,Pending))
r325: locker2_map_claim_lock(nil(),Resources,Client) -> nil()
r326: locker2_map_claim_lock(cons(Lock,Locks),Resources,Client) -> cons(locker2_claim_lock(Lock,Resources,Client),locker2_map_claim_lock(Locks,Resources,Client))
r327: locker2_map_add_pending(nil(),Resources,Client) -> nil()
r328: locker2_promote_pending(Lock,Client) -> case0(Client,Lock,record_extract(Lock,lock(),pending()))
r329: case0(Client,Lock,cons(Client,Pendings)) -> record_updates(Lock,lock(),cons(tuple(excl(),tuplenil(Client)),cons(tuple(pending(),tuplenil(Pendings)),nil())))
r330: case0(Client,Lock,MCRLFree0) -> Lock
r331: locker2_remove_pending(Lock,Client) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(subtract(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r332: locker2_add_pending(Lock,Resources,Client) -> case1(Client,Resources,Lock,member(record_extract(Lock,lock(),resource()),Resources))
r333: case1(Client,Resources,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(pending(),tuplenil(append(record_extract(Lock,lock(),pending()),cons(Client,nil())))),nil()))
r334: case1(Client,Resources,Lock,false()) -> Lock
r335: locker2_release_lock(Lock,Client) -> case2(Client,Lock,gen_modtageq(Client,record_extract(Lock,lock(),excl())))
r336: case2(Client,Lock,true()) -> record_updates(Lock,lock(),cons(tuple(excllock(),excl()),nil()))
r337: case4(Client,Lock,MCRLFree1) -> false()
r338: locker2_obtainables(nil(),Client) -> true()
r339: locker2_obtainables(cons(Lock,Locks),Client) -> case5(Client,Locks,Lock,member(Client,record_extract(Lock,lock(),pending())))
r340: case5(Client,Locks,Lock,true()) -> andt(locker2_obtainable(Lock,Client),locker2_obtainables(Locks,Client))
r341: case5(Client,Locks,Lock,false()) -> locker2_obtainables(Locks,Client)
r342: locker2_check_available(Resource,nil()) -> false()
r343: locker2_check_available(Resource,cons(Lock,Locks)) -> case6(Locks,Lock,Resource,equal(Resource,record_extract(Lock,lock(),resource())))
r344: case6(Locks,Lock,Resource,true()) -> andt(equal(record_extract(Lock,lock(),excl()),nil()),equal(record_extract(Lock,lock(),pending()),nil()))
r345: case6(Locks,Lock,Resource,false()) -> locker2_check_available(Resource,Locks)
r346: locker2_check_availables(nil(),Locks) -> true()
r347: locker2_check_availables(cons(Resource,Resources),Locks) -> andt(locker2_check_available(Resource,Locks),locker2_check_availables(Resources,Locks))
r348: locker2_adduniq(nil(),List) -> List
r349: append(cons(Head,Tail),List) -> cons(Head,append(Tail,List))
r350: subtract(List,nil()) -> List
r351: subtract(List,cons(Head,Tail)) -> subtract(delete(Head,List),Tail)
r352: delete(E,nil()) -> nil()
r353: delete(E,cons(Head,Tail)) -> case8(Tail,Head,E,equal(E,Head))
r354: case8(Tail,Head,E,true()) -> Tail
r355: case8(Tail,Head,E,false()) -> cons(Head,delete(E,Tail))
r356: gen_tag(Pid) -> tuple(Pid,tuplenil(tag()))
r357: gen_modtageq(Client1,Client2) -> equal(Client1,Client2)
r358: member(E,nil()) -> false()
r359: member(E,cons(Head,Tail)) -> case9(Tail,Head,E,equal(E,Head))
r360: case9(Tail,Head,E,true()) -> true()
r361: case9(Tail,Head,E,false()) -> member(E,Tail)
r362: eqs(empty(),empty()) -> T()
r363: eqs(empty(),stack(E2,S2)) -> F()
r364: eqs(stack(E1,S1),empty()) -> F()
r365: eqs(stack(E1,S1),stack(E2,S2)) -> and(eqt(E1,E2),eqs(S1,S2))
r366: pushs(E1,S1) -> stack(E1,S1)
r367: pops(stack(E1,S1)) -> S1
r368: tops(stack(E1,S1)) -> E1
r369: istops(E1,empty()) -> F()
r370: istops(E1,stack(E2,S1)) -> eqt(E1,E2)
r371: eqc(nocalls(),nocalls()) -> T()
r372: eqc(nocalls(),calls(E2,S2,CS2)) -> F()
r373: eqc(calls(E1,S1,CS1),nocalls()) -> F()
r374: eqc(calls(E1,S1,CS1),calls(E2,S2,CS2)) -> and(eqt(E1,E2),and(eqs(S1,S2),eqc(CS1,CS2)))
r375: push(E1,E2,nocalls()) -> calls(E1,stack(E2,empty()),nocalls())
r376: push(E1,E2,calls(E3,S1,CS1)) -> push1(E1,E2,E3,S1,CS1,eqt(E1,E3))
r377: push1(E1,E2,E3,S1,CS1,T()) -> calls(E3,pushs(E2,S1),CS1)

The set of usable rules consists of

  r9, r13, r14, r15, r16, r18, r337, r339, r348, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      matrix interpretation with standard point-wise order:
      
        carrier: N^1
        order: standard order
        interpretations:
          append#_A(x1,x2) = x1
          cons_A(x1,x2) = x2 + 51
          imp_A(x1,x2) = x2 + 57
          T_A() = 56
          if_A(x1,x2,x3) = x2 + x3 + 1
          F_A() = 53
          eq_A(x1,x2) = 57
          case4_A(x1,x2,x3) = x3 + 45
          false_A() = 44
          locker2_obtainables_A(x1,x2) = 43
          case5_A(x1,x2,x3,x4) = x4
          member_A(x1,x2) = x2 + 1
          record_extract_A(x1,x2,x3) = 40
          lock_A() = 42
          pending_A() = 52
          locker2_adduniq_A(x1,x2) = x2 + 1
          nil_A() = 46
          case9_A(x1,x2,x3,x4) = 50
          equal_A(x1,x2) = x2 + 2
  
    base order 2:
  
      marked-algebra reduction triple (>=A, >=A!, >A!):
      
        matrix interpretation with standard point-wise order:
        
          carrier: N^1
          order: standard order
          interpretations:
            append#_A(x1,x2) = x1
            cons_A(x1,x2) = x1 + x2 + 2
            imp_A(x1,x2) = x2
            T_A() = 2
            if_A(x1,x2,x3) = x2 + x3
            F_A() = 3
            eq_A(x1,x2) = x1
            case4_A(x1,x2,x3) = 2
            false_A() = 2
            locker2_obtainables_A(x1,x2) = 1
            case5_A(x1,x2,x3,x4) = 0
            member_A(x1,x2) = 1
            record_extract_A(x1,x2,x3) = x1 + 20
            lock_A() = 1
            pending_A() = 1
            locker2_adduniq_A(x1,x2) = x2
            nil_A() = 7
            case9_A(x1,x2,x3,x4) = 0
            equal_A(x1,x2) = 2
            append#!_A(x1,x2) = 0
            cons!_A(x1,x2) = 19
            imp!_A(x1,x2) = 10
            T!_A() = 9
            if!_A(x1,x2,x3) = x1 + x2 + x3
            F!_A() = 5
            eq!_A(x1,x2) = 10
            case4!_A(x1,x2,x3) = 7
            false!_A() = 6
            locker2_obtainables!_A(x1,x2) = 2
            case5!_A(x1,x2,x3,x4) = x1 + x2 + 3
            member!_A(x1,x2) = x2
            record_extract!_A(x1,x2,x3) = 18
            lock!_A() = 2
            pending!_A() = 22
            locker2_adduniq!_A(x1,x2) = x1 + x2
            nil!_A() = 13
            case9!_A(x1,x2,x3,x4) = 19
            equal!_A(x1,x2) = x2 + 9
  
    partial status:
  
      pi(append#) = []
      pi(cons) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(eq) = []
      pi(case4) = [3]
      pi(false) = []
      pi(locker2_obtainables) = []
      pi(case5) = []
      pi(member) = []
      pi(record_extract) = []
      pi(lock) = []
      pi(pending) = []
      pi(locker2_adduniq) = [2]
      pi(nil) = []
      pi(case9) = []
      pi(equal) = []

The following rules are removed:

  p1

Then no dependency pair remains.