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

  r13, r14, r327, r348, r353, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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) = x3 + 1
              if_A(x1,x2,x3) = x2 + x3
              T_A() = 54
              F_A() = 53
              locker2_map_add_pending_A(x1,x2,x3) = 24
              nil_A() = 24
              locker2_adduniq_A(x1,x2) = x2
              delete_A(x1,x2) = x1
              cons_A(x1,x2) = 4
              case8_A(x1,x2,x3,x4) = 0
              equal_A(x1,x2) = 2
              member_A(x1,x2) = 1
              case9_A(x1,x2,x3,x4) = 0
              eqc#!_A(x1,x2) = x1 + x2
              calls!_A(x1,x2,x3) = 10
              if!_A(x1,x2,x3) = x1 + x2 + x3
              T!_A() = 1
              F!_A() = 7
              locker2_map_add_pending!_A(x1,x2,x3) = 0
              nil!_A() = 25
              locker2_adduniq!_A(x1,x2) = x1 + x2
              delete!_A(x1,x2) = x1 + 26
              cons!_A(x1,x2) = x1 + 19
              case8!_A(x1,x2,x3,x4) = 18
              equal!_A(x1,x2) = 20
              member!_A(x1,x2) = 15
              case9!_A(x1,x2,x3,x4) = 14
        
        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) = x3 + 1
              if_A(x1,x2,x3) = x2 + x3
              T_A() = 74
              F_A() = 41
              locker2_map_add_pending_A(x1,x2,x3) = 31
              nil_A() = 31
              locker2_adduniq_A(x1,x2) = x2
              delete_A(x1,x2) = x1 + x2 + 37
              cons_A(x1,x2) = x1 + x2 + 36
              case8_A(x1,x2,x3,x4) = 72
              equal_A(x1,x2) = 2
              member_A(x1,x2) = 1
              case9_A(x1,x2,x3,x4) = 0
              eqc#!_A(x1,x2) = x1 + x2 + 193
              calls!_A(x1,x2,x3) = x2 + 192
              if!_A(x1,x2,x3) = x1 + x2 + x3
              T!_A() = 185
              F!_A() = 191
              locker2_map_add_pending!_A(x1,x2,x3) = 0
              nil!_A() = 193
              locker2_adduniq!_A(x1,x2) = x1 + x2
              delete!_A(x1,x2) = x2 + 193
              cons!_A(x1,x2) = 159
              case8!_A(x1,x2,x3,x4) = 160
              equal!_A(x1,x2) = x1 + x2 + 158
              member!_A(x1,x2) = 160
              case9!_A(x1,x2,x3,x4) = x3 + 145
        
  
    partial status:
  
      pi(eqc#) = []
      pi(calls) = [3]
      pi(if) = [2, 3]
      pi(T) = []
      pi(F) = []
      pi(locker2_map_add_pending) = [1, 3]
      pi(nil) = []
      pi(locker2_adduniq) = [2]
      pi(delete) = [1, 2]
      pi(cons) = []
      pi(case8) = []
      pi(equal) = [1]
      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: 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

  r13, r14, r29, r49, r61, r172, r212, r220, r299, r339, r342, r348, r356, r367

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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) = x1 + x2 + 2
              if_A(x1,x2,x3) = x1 + x2 + x3
              T_A() = 168
              F_A() = 68
              eqt_A(x1,x2) = x1 + x2 + 3
              a_A() = 20
              lock_A() = 82
              excl_A() = 6
              false_A() = 36
              int_A(x1) = x1 + 20
              resource_A() = 1
              true_A() = 20
              tag_A() = 45
              tuplenil_A(x1) = 1
              locker2_obtainables_A(x1,x2) = 1
              cons_A(x1,x2) = x1 + x2 + 21
              case5_A(x1,x2,x3,x4) = 0
              member_A(x1,x2) = 1
              record_extract_A(x1,x2,x3) = 1
              pending_A() = 19
              locker2_check_available_A(x1,x2) = x2 + 151
              nil_A() = 20
              locker2_adduniq_A(x1,x2) = x2
              gen_tag_A(x1) = 20
              tuple_A(x1,x2) = 20
              pops_A(x1) = x1
              eqs#!_A(x1,x2) = x1 + x2
              stack!_A(x1,x2) = 104
              if!_A(x1,x2,x3) = x1 + x2 + x3
              T!_A() = 67
              F!_A() = 103
              eqt!_A(x1,x2) = x2 + 96
              a!_A() = 104
              lock!_A() = 68
              excl!_A() = 112
              false!_A() = 104
              int!_A(x1) = 117
              resource!_A() = 115
              true!_A() = 149
              tag!_A() = 104
              tuplenil!_A(x1) = x1 + 70
              locker2_obtainables!_A(x1,x2) = 107
              cons!_A(x1,x2) = x2 + 128
              case5!_A(x1,x2,x3,x4) = x4 + 86
              member!_A(x1,x2) = x2 + 105
              record_extract!_A(x1,x2,x3) = x3 + 112
              pending!_A() = 108
              locker2_check_available!_A(x1,x2) = 116
              nil!_A() = 105
              locker2_adduniq!_A(x1,x2) = x1 + x2
              gen_tag!_A(x1) = 114
              tuple!_A(x1,x2) = 114
              pops!_A(x1) = x1
        
        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
              if_A(x1,x2,x3) = x2 + x3
              T_A() = 27
              F_A() = 12
              eqt_A(x1,x2) = x1 + 3
              a_A() = 9
              lock_A() = 1
              excl_A() = 9
              false_A() = 2
              int_A(x1) = x1 + 8
              resource_A() = 23
              true_A() = 9
              tag_A() = 8
              tuplenil_A(x1) = 9
              locker2_obtainables_A(x1,x2) = 1
              cons_A(x1,x2) = 3
              case5_A(x1,x2,x3,x4) = 0
              member_A(x1,x2) = 1
              record_extract_A(x1,x2,x3) = x1 + x3
              pending_A() = 5
              locker2_check_available_A(x1,x2) = 2
              nil_A() = 8
              locker2_adduniq_A(x1,x2) = x2
              gen_tag_A(x1) = 2
              tuple_A(x1,x2) = 2
              pops_A(x1) = x1
              eqs#!_A(x1,x2) = x2 + 28
              stack!_A(x1,x2) = 27
              if!_A(x1,x2,x3) = x1 + x2 + x3
              T!_A() = 35
              F!_A() = 28
              eqt!_A(x1,x2) = 28
              a!_A() = 29
              lock!_A() = 40
              excl!_A() = 27
              false!_A() = 1
              int!_A(x1) = x1 + 38
              resource!_A() = 44
              true!_A() = 29
              tag!_A() = 36
              tuplenil!_A(x1) = 22
              locker2_obtainables!_A(x1,x2) = x1 + 30
              cons!_A(x1,x2) = 39
              case5!_A(x1,x2,x3,x4) = 31
              member!_A(x1,x2) = x1 + 41
              record_extract!_A(x1,x2,x3) = x2 + x3 + 18
              pending!_A() = 34
              locker2_check_available!_A(x1,x2) = 43
              nil!_A() = 2
              locker2_adduniq!_A(x1,x2) = x1 + x2
              gen_tag!_A(x1) = 41
              tuple!_A(x1,x2) = 41
              pops!_A(x1) = x1
        
  
    partial status:
  
      pi(eqs#) = []
      pi(stack) = [2]
      pi(if) = [2, 3]
      pi(T) = []
      pi(F) = []
      pi(eqt) = [1]
      pi(a) = []
      pi(lock) = []
      pi(excl) = []
      pi(false) = []
      pi(int) = [1]
      pi(resource) = []
      pi(true) = []
      pi(tag) = []
      pi(tuplenil) = []
      pi(locker2_obtainables) = []
      pi(cons) = []
      pi(case5) = []
      pi(member) = []
      pi(record_extract) = []
      pi(pending) = []
      pi(locker2_check_available) = [1, 2]
      pi(nil) = []
      pi(locker2_adduniq) = [2]
      pi(gen_tag) = [1]
      pi(tuple) = [1]
      pi(pops) = [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: 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

  r13, r14, r111, r221, r348, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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
              tuplenil_A(x1) = 0
              tuple_A(x1,x2) = x2 + 26
              cons_A(x1,x2) = x1 + x2 + 2
              if_A(x1,x2,x3) = x1 + x2 + x3
              T_A() = 58
              F_A() = 117
              eqt_A(x1,x2) = x1 + 31
              mcrlrecord_A() = 27
              true_A() = 27
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 2
              member_A(x1,x2) = 1
              case9_A(x1,x2,x3,x4) = 0
              equal_A(x1,x2) = 2
              eqt#!_A(x1,x2) = x1 + 59
              pid!_A(x1) = x1 + 83
              tuplenil!_A(x1) = x1 + 60
              tuple!_A(x1,x2) = x1 + x2 + 63
              cons!_A(x1,x2) = x1 + 86
              if!_A(x1,x2,x3) = x1 + x2 + x3
              T!_A() = 60
              F!_A() = 82
              eqt!_A(x1,x2) = 61
              mcrlrecord!_A() = 88
              true!_A() = 80
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 81
              member!_A(x1,x2) = 75
              case9!_A(x1,x2,x3,x4) = 74
              equal!_A(x1,x2) = x2 + 74
        
        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
              tuplenil_A(x1) = 0
              tuple_A(x1,x2) = x1 + 10
              cons_A(x1,x2) = x1 + 32
              if_A(x1,x2,x3) = x2 + x3
              T_A() = 35
              F_A() = 79
              eqt_A(x1,x2) = x1 + 10
              mcrlrecord_A() = 27
              true_A() = 25
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 68
              member_A(x1,x2) = 1
              case9_A(x1,x2,x3,x4) = 0
              equal_A(x1,x2) = 20
              eqt#!_A(x1,x2) = x1 + 2
              pid!_A(x1) = x1 + 31
              tuplenil!_A(x1) = x1 + 29
              tuple!_A(x1,x2) = x1 + 1
              cons!_A(x1,x2) = 73
              if!_A(x1,x2,x3) = x1 + x2 + x3
              T!_A() = 59
              F!_A() = 61
              eqt!_A(x1,x2) = x1 + x2 + 30
              mcrlrecord!_A() = 62
              true!_A() = 110
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 67
              member!_A(x1,x2) = x2 + 75
              case9!_A(x1,x2,x3,x4) = x2 + 74
              equal!_A(x1,x2) = x1 + 108
        
  
    partial status:
  
      pi(eqt#) = [1]
      pi(pid) = [1]
      pi(tuplenil) = [1]
      pi(tuple) = [1, 2]
      pi(cons) = [1, 2]
      pi(if) = [2, 3]
      pi(T) = []
      pi(F) = []
      pi(eqt) = [2]
      pi(mcrlrecord) = []
      pi(true) = []
      pi(locker2_adduniq) = [2]
      pi(nil) = []
      pi(member) = []
      pi(case9) = []
      pi(equal) = []

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, r344, r348

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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) = 0
              int_A(x1) = 1
              s_A(x1) = x1 + 1
              tuple_A(x1,x2) = 8
              imp_A(x1,x2) = x2
              T_A() = 32
              if_A(x1,x2,x3) = x2 + x3
              case6_A(x1,x2,x3,x4) = 3
              true_A() = 2
              andt_A(x1,x2) = 3
              equal_A(x1,x2) = 14
              record_extract_A(x1,x2,x3) = 7
              lock_A() = 1
              excl_A() = 1
              nil_A() = 2
              pending_A() = 1
              locker2_adduniq_A(x1,x2) = x2
              element#!_A(x1,x2) = 0
              int!_A(x1) = x1
              s!_A(x1) = x1 + 2
              tuple!_A(x1,x2) = 10
              imp!_A(x1,x2) = x1
              T!_A() = 5
              if!_A(x1,x2,x3) = x1 + x2 + x3
              case6!_A(x1,x2,x3,x4) = 27
              true!_A() = 19
              andt!_A(x1,x2) = 0
              equal!_A(x1,x2) = 26
              record_extract!_A(x1,x2,x3) = 23
              lock!_A() = 8
              excl!_A() = 6
              nil!_A() = 15
              pending!_A() = 18
              locker2_adduniq!_A(x1,x2) = x1 + x2
        
        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) = 0
              int_A(x1) = x1 + 1
              s_A(x1) = x1 + 9
              tuple_A(x1,x2) = 2
              imp_A(x1,x2) = x2
              T_A() = 4
              if_A(x1,x2,x3) = x1 + x2 + x3
              case6_A(x1,x2,x3,x4) = 3
              true_A() = 2
              andt_A(x1,x2) = 3
              equal_A(x1,x2) = 14
              record_extract_A(x1,x2,x3) = x1 + 13
              lock_A() = 8
              excl_A() = 11
              nil_A() = 2
              pending_A() = 11
              locker2_adduniq_A(x1,x2) = x2
              element#!_A(x1,x2) = x1 + 10
              int!_A(x1) = x1 + 10
              s!_A(x1) = x1 + 28
              tuple!_A(x1,x2) = x1 + 27
              imp!_A(x1,x2) = 5
              T!_A() = 4
              if!_A(x1,x2,x3) = x1 + x2 + x3
              case6!_A(x1,x2,x3,x4) = x1 + x2 + 38
              true!_A() = 37
              andt!_A(x1,x2) = x1 + 23
              equal!_A(x1,x2) = x2 + 27
              record_extract!_A(x1,x2,x3) = x1 + x3 + 16
              lock!_A() = 1
              excl!_A() = 36
              nil!_A() = 35
              pending!_A() = 25
              locker2_adduniq!_A(x1,x2) = x1 + x2
        
  
    partial status:
  
      pi(element#) = []
      pi(int) = [1]
      pi(s) = []
      pi(tuple) = [1]
      pi(imp) = [1, 2]
      pi(T) = []
      pi(if) = [2]
      pi(case6) = [2, 4]
      pi(true) = []
      pi(andt) = []
      pi(equal) = []
      pi(record_extract) = [1, 2, 3]
      pi(lock) = []
      pi(excl) = []
      pi(nil) = []
      pi(pending) = []
      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: 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, r348, r371, r372, r373

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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 + 6
              tuple_A(x1,x2) = x1 + 2
              tuplenil_A(x1) = 3
              record_update_A(x1,x2,x3,x4) = x1 + x3 + 1
              imp_A(x1,x2) = x2
              T_A() = 14
              if_A(x1,x2,x3) = x2 + x3
              F_A() = 13
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 32
              eqc_A(x1,x2) = x1 + x2 + 7
              nocalls_A() = 5
              calls_A(x1,x2,x3) = x1 + 1
              record_updates#!_A(x1,x2,x3) = x2 + x3 + 71
              cons!_A(x1,x2) = x2 + 70
              tuple!_A(x1,x2) = 86
              tuplenil!_A(x1) = x1 + 81
              record_update!_A(x1,x2,x3,x4) = 80
              imp!_A(x1,x2) = 84
              T!_A() = 83
              if!_A(x1,x2,x3) = x1 + x2 + x3
              F!_A() = 66
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 67
              eqc!_A(x1,x2) = 85
              nocalls!_A() = 84
              calls!_A(x1,x2,x3) = x1 + x2 + 81
        
        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 + 2
              tuple_A(x1,x2) = 1
              tuplenil_A(x1) = 0
              record_update_A(x1,x2,x3,x4) = x1 + 1
              imp_A(x1,x2) = x2
              T_A() = 2
              if_A(x1,x2,x3) = x2 + x3
              F_A() = 5
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 1
              eqc_A(x1,x2) = 5
              nocalls_A() = 10
              calls_A(x1,x2,x3) = x1 + x2 + x3 + 1
              record_updates#!_A(x1,x2,x3) = x2 + x3 + 19
              cons!_A(x1,x2) = 18
              tuple!_A(x1,x2) = 12
              tuplenil!_A(x1) = 4
              record_update!_A(x1,x2,x3,x4) = 0
              imp!_A(x1,x2) = 4
              T!_A() = 3
              if!_A(x1,x2,x3) = x1 + x2 + x3
              F!_A() = 9
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 1
              eqc!_A(x1,x2) = x2
              nocalls!_A() = 4
              calls!_A(x1,x2,x3) = x1 + x2 + 8
        
  
    partial status:
  
      pi(record_updates#) = [3]
      pi(cons) = [2]
      pi(tuple) = [2]
      pi(tuplenil) = [1]
      pi(record_update) = []
      pi(imp) = [2]
      pi(T) = []
      pi(if) = [2, 3]
      pi(F) = []
      pi(locker2_adduniq) = [2]
      pi(nil) = []
      pi(eqc) = [1, 2]
      pi(nocalls) = []
      pi(calls) = [3]

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

  r1, r2, r3, r9, r13, r15, r16, r348, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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) = 0
              cons_A(x1,x2) = 15
              or_A(x1,x2) = 5
              T_A() = 5
              F_A() = 6
              imp_A(x1,x2) = x2
              if_A(x1,x2,x3) = x2 + x3
              eq_A(x1,x2) = 5
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 5
              member_A(x1,x2) = 1
              case9_A(x1,x2,x3,x4) = 0
              equal_A(x1,x2) = 2
              locker2_map_promote_pending#!_A(x1,x2) = 0
              cons!_A(x1,x2) = x2 + 21
              or!_A(x1,x2) = x1
              T!_A() = 11
              F!_A() = 7
              imp!_A(x1,x2) = 12
              if!_A(x1,x2,x3) = x1 + x2 + x3
              eq!_A(x1,x2) = 12
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 19
              member!_A(x1,x2) = 13
              case9!_A(x1,x2,x3,x4) = 20
              equal!_A(x1,x2) = 17
        
        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) = x2 + 9
              or_A(x1,x2) = 48
              T_A() = 48
              F_A() = 50
              imp_A(x1,x2) = x2
              if_A(x1,x2,x3) = x2 + x3
              eq_A(x1,x2) = 48
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 16
              member_A(x1,x2) = 1
              case9_A(x1,x2,x3,x4) = 0
              equal_A(x1,x2) = 2
              locker2_map_promote_pending#!_A(x1,x2) = 0
              cons!_A(x1,x2) = 47
              or!_A(x1,x2) = x1 + 67
              T!_A() = 116
              F!_A() = 76
              imp!_A(x1,x2) = 117
              if!_A(x1,x2,x3) = x1 + x2 + x3
              eq!_A(x1,x2) = 117
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 46
              member!_A(x1,x2) = 43
              case9!_A(x1,x2,x3,x4) = 76
              equal!_A(x1,x2) = 44
        
  
    partial status:
  
      pi(locker2_map_promote_pending#) = [1]
      pi(cons) = [2]
      pi(or) = [1, 2]
      pi(T) = []
      pi(F) = []
      pi(imp) = [2]
      pi(if) = [2]
      pi(eq) = [1, 2]
      pi(locker2_adduniq) = [2]
      pi(nil) = []
      pi(member) = [2]
      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

  r13, r14, r20, r36, r39, r40, r57, r77, r80, r97, r100, r121, r137, r138, r140, r141, r142, r163, r180, r182, r183, r184, r194, r199, r202, r203, r204, r220, r223, r237, r242, r243, r244, r262, r263, r267, r270, r287, r290, r307, r310, r338, r348

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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) = 0
              cons_A(x1,x2) = x1 + 3
              if_A(x1,x2,x3) = x2 + x3
              T_A() = 88
              F_A() = 45
              eqt_A(x1,x2) = x1 + x2 + 3
              nil_A() = 2
              pid_A(x1) = x1 + 42
              a_A() = 20
              resource_A() = 25
              undefined_A() = 22
              excl_A() = 7
              tag_A() = 42
              lock_A() = 16
              locker_A() = 16
              ok_A() = 1
              pending_A() = 23
              int_A(x1) = x1 + 19
              request_A() = 16
              mcrlrecord_A() = 1
              true_A() = 16
              tuple_A(x1,x2) = x2
              tuplenil_A(x1) = x1
              locker2_obtainables_A(x1,x2) = 16
              locker2_adduniq_A(x1,x2) = x2
              locker2_map_claim_lock#!_A(x1,x2,x3) = 0
              cons!_A(x1,x2) = x1 + 148
              if!_A(x1,x2,x3) = x1 + x2 + x3
              T!_A() = 130
              F!_A() = 89
              eqt!_A(x1,x2) = x1 + 106
              nil!_A() = 137
              pid!_A(x1) = 107
              a!_A() = 131
              resource!_A() = 131
              undefined!_A() = 90
              excl!_A() = 140
              tag!_A() = 131
              lock!_A() = 133
              locker!_A() = 90
              ok!_A() = 90
              pending!_A() = 132
              int!_A(x1) = 22
              request!_A() = 131
              mcrlrecord!_A() = 150
              true!_A() = 142
              tuple!_A(x1,x2) = 132
              tuplenil!_A(x1) = x1 + 105
              locker2_obtainables!_A(x1,x2) = x1 + 143
              locker2_adduniq!_A(x1,x2) = x1 + x2
        
        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 + 3
              if_A(x1,x2,x3) = x2 + x3
              T_A() = 20
              F_A() = 16
              eqt_A(x1,x2) = x2 + 3
              nil_A() = 7
              pid_A(x1) = x1 + 13
              a_A() = 7
              resource_A() = 13
              undefined_A() = 13
              excl_A() = 9
              tag_A() = 13
              lock_A() = 5
              locker_A() = 12
              ok_A() = 7
              pending_A() = 7
              int_A(x1) = x1 + 13
              request_A() = 12
              mcrlrecord_A() = 13
              true_A() = 13
              tuple_A(x1,x2) = 8
              tuplenil_A(x1) = 7
              locker2_obtainables_A(x1,x2) = 13
              locker2_adduniq_A(x1,x2) = x2
              locker2_map_claim_lock#!_A(x1,x2,x3) = x1
              cons!_A(x1,x2) = 49
              if!_A(x1,x2,x3) = x1 + x2 + x3
              T!_A() = 39
              F!_A() = 37
              eqt!_A(x1,x2) = x1 + 31
              nil!_A() = 58
              pid!_A(x1) = 38
              a!_A() = 40
              resource!_A() = 52
              undefined!_A() = 0
              excl!_A() = 60
              tag!_A() = 38
              lock!_A() = 45
              locker!_A() = 40
              ok!_A() = 38
              pending!_A() = 40
              int!_A(x1) = 34
              request!_A() = 38
              mcrlrecord!_A() = 38
              true!_A() = 48
              tuple!_A(x1,x2) = 36
              tuplenil!_A(x1) = 30
              locker2_obtainables!_A(x1,x2) = 44
              locker2_adduniq!_A(x1,x2) = x1 + x2
        
  
    partial status:
  
      pi(locker2_map_claim_lock#) = []
      pi(cons) = []
      pi(if) = [2, 3]
      pi(T) = []
      pi(F) = []
      pi(eqt) = [1]
      pi(nil) = []
      pi(pid) = []
      pi(a) = []
      pi(resource) = []
      pi(undefined) = []
      pi(excl) = []
      pi(tag) = []
      pi(lock) = []
      pi(locker) = []
      pi(ok) = []
      pi(pending) = []
      pi(int) = []
      pi(request) = []
      pi(mcrlrecord) = []
      pi(true) = []
      pi(tuple) = []
      pi(tuplenil) = []
      pi(locker2_obtainables) = []
      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: 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, r14, r348

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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) = 0
              cons_A(x1,x2) = 15
              delete_A(x1,x2) = x2 + 1
              imp_A(x1,x2) = x2
              T_A() = 42
              if_A(x1,x2,x3) = x2 + x3
              F_A() = 23
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 16
              subtract#!_A(x1,x2) = 26
              cons!_A(x1,x2) = 29
              delete!_A(x1,x2) = 26
              imp!_A(x1,x2) = x1
              T!_A() = 2
              if!_A(x1,x2,x3) = x1 + x2 + x3
              F!_A() = 26
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 7
        
        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) = 0
              cons_A(x1,x2) = x1 + 4
              delete_A(x1,x2) = x2 + 4
              imp_A(x1,x2) = x2
              T_A() = 11
              if_A(x1,x2,x3) = x2 + x3
              F_A() = 5
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 6
              subtract#!_A(x1,x2) = 57
              cons!_A(x1,x2) = x2 + 58
              delete!_A(x1,x2) = x2 + 56
              imp!_A(x1,x2) = 78
              T!_A() = 77
              if!_A(x1,x2,x3) = x1 + x2 + x3
              F!_A() = 71
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 61
        
  
    partial status:
  
      pi(subtract#) = [2]
      pi(cons) = [2]
      pi(delete) = [2]
      pi(imp) = [1, 2]
      pi(T) = []
      pi(if) = [3]
      pi(F) = []
      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_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

  r1, r2, r3, r9, r13, r15, r16, r320, r348, r359

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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) = 6
              or_A(x1,x2) = 13
              T_A() = 13
              F_A() = 14
              imp_A(x1,x2) = x2
              if_A(x1,x2,x3) = x2 + x3
              eq_A(x1,x2) = 13
              record_update_A(x1,x2,x3,x4) = x1 + 1
              tuple_A(x1,x2) = 1
              mcrlrecord_A() = 1
              lock_A() = 1
              tuplenil_A(x1) = 2
              pending_A() = 1
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 1
              member_A(x1,x2) = 1
              case9_A(x1,x2,x3,x4) = 0
              equal_A(x1,x2) = 2
              locker2_check_availables#!_A(x1,x2) = 0
              cons!_A(x1,x2) = 22
              or!_A(x1,x2) = x1
              T!_A() = 15
              F!_A() = 15
              imp!_A(x1,x2) = 16
              if!_A(x1,x2,x3) = x1 + x2 + x3
              eq!_A(x1,x2) = 16
              record_update!_A(x1,x2,x3,x4) = 27
              tuple!_A(x1,x2) = x2 + 24
              mcrlrecord!_A() = 14
              lock!_A() = 13
              tuplenil!_A(x1) = 28
              pending!_A() = 17
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 20
              member!_A(x1,x2) = 24
              case9!_A(x1,x2,x3,x4) = 23
              equal!_A(x1,x2) = x2 + 18
        
        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) = x1
              cons_A(x1,x2) = x1 + x2 + 23
              or_A(x1,x2) = 60
              T_A() = 60
              F_A() = 62
              imp_A(x1,x2) = x2
              if_A(x1,x2,x3) = x2 + x3
              eq_A(x1,x2) = 60
              record_update_A(x1,x2,x3,x4) = x1 + 1
              tuple_A(x1,x2) = 23
              mcrlrecord_A() = 7
              lock_A() = 5
              tuplenil_A(x1) = 19
              pending_A() = 21
              locker2_adduniq_A(x1,x2) = x2
              nil_A() = 15
              member_A(x1,x2) = 1
              case9_A(x1,x2,x3,x4) = 0
              equal_A(x1,x2) = 15
              locker2_check_availables#!_A(x1,x2) = x1
              cons!_A(x1,x2) = x2 + 69
              or!_A(x1,x2) = x1
              T!_A() = 61
              F!_A() = 61
              imp!_A(x1,x2) = 62
              if!_A(x1,x2,x3) = x1 + x2 + x3
              eq!_A(x1,x2) = x2 + 2
              record_update!_A(x1,x2,x3,x4) = 75
              tuple!_A(x1,x2) = 73
              mcrlrecord!_A() = 74
              lock!_A() = 62
              tuplenil!_A(x1) = 76
              pending!_A() = 64
              locker2_adduniq!_A(x1,x2) = x1 + x2
              nil!_A() = 80
              member!_A(x1,x2) = 66
              case9!_A(x1,x2,x3,x4) = 65
              equal!_A(x1,x2) = x2 + 67
        
  
    partial status:
  
      pi(locker2_check_availables#) = [1]
      pi(cons) = [2]
      pi(or) = [1, 2]
      pi(T) = []
      pi(F) = []
      pi(imp) = [1, 2]
      pi(if) = [2]
      pi(eq) = [1, 2]
      pi(record_update) = []
      pi(tuple) = [1]
      pi(mcrlrecord) = []
      pi(lock) = []
      pi(tuplenil) = []
      pi(pending) = []
      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: 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

  r1, r2, r3, r9, r13, r15, r16, r321, r348

Take the reduction pair:

  generalized weighted path order (>=MG, >G)
  
    base order 1:
  
      trivial reduction triple (T x T, T x T, Φ)
  
    base order 2:
  
      lexicographic combination of reduction triples:
      
        1. 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) = 0
              cons_A(x1,x2) = 11
              or_A(x1,x2) = 6
              T_A() = 6
              F_A() = 7
              imp_A(x1,x2) = x2
              if_A(x1,x2,x3) = x2 + x3
              eq_A(x1,x2) = 6
              record_updates_A(x1,x2,x3) = x1 + x3
              nil_A() = 2
              locker2_adduniq_A(x1,x2) = x2
              append#!_A(x1,x2) = 0
              cons!_A(x1,x2) = 24
              or!_A(x1,x2) = x1 + 4
              T!_A() = 10
              F!_A() = 12
              imp!_A(x1,x2) = 11
              if!_A(x1,x2,x3) = x1 + x2 + x3
              eq!_A(x1,x2) = 13
              record_updates!_A(x1,x2,x3) = 29
              nil!_A() = 8
              locker2_adduniq!_A(x1,x2) = x1 + x2
        
        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 + 12
              or_A(x1,x2) = 100
              T_A() = 100
              F_A() = 101
              imp_A(x1,x2) = x2
              if_A(x1,x2,x3) = x2 + x3
              eq_A(x1,x2) = 100
              record_updates_A(x1,x2,x3) = x1 + 14
              nil_A() = 2
              locker2_adduniq_A(x1,x2) = x2
              append#!_A(x1,x2) = 0
              cons!_A(x1,x2) = 143
              or!_A(x1,x2) = x1
              T!_A() = 99
              F!_A() = 102
              imp!_A(x1,x2) = x1
              if!_A(x1,x2,x3) = x1 + x2 + x3
              eq!_A(x1,x2) = 103
              record_updates!_A(x1,x2,x3) = x1 + x3 + 60
              nil!_A() = 135
              locker2_adduniq!_A(x1,x2) = x1 + x2
        
  
    partial status:
  
      pi(append#) = [1]
      pi(cons) = [2]
      pi(or) = [1, 2]
      pi(T) = []
      pi(F) = []
      pi(imp) = [1, 2]
      pi(if) = [2]
      pi(eq) = [1, 2]
      pi(record_updates) = [1]
      pi(nil) = []
      pi(locker2_adduniq) = [2]

The following rules are removed:

  p1

Then no dependency pair remains.