YES Problem 1: (VAR v_NonEmpty:S B:S B1:S B2:S CS1:S CS2:S Client:S Client1:S Client2:S E:S E1:S E2:S E3:S F0:S F1:S F2:S Field:S Fields:S H1:S H2:S Head:S List:S Lock:S Locks:S MCRLFree0:S MCRLFree1:S N1:S N2:S Name:S NewF:S Pending:S Pendings:S Pid:S Record:S Resource:S Resources:S S1:S S2:S T1:S T2:S Tail:S) (RULES and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ) Problem 1: Dependency Pairs Processor: -> Pairs: APPEND(cons(Head:S,Tail:S),List:S) -> APPEND(Tail:S,List:S) CASE0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> RECORD_UPDATES(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) CASE1(Client:S,Resources:S,Lock:S,ttrue) -> RECORD_UPDATES(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) CASE5(Client:S,Locks:S,Lock:S,ffalse) -> LOCKER2_OBTAINABLES(Locks:S,Client:S) CASE5(Client:S,Locks:S,Lock:S,ttrue) -> LOCKER2_OBTAINABLES(Locks:S,Client:S) CASE6(Locks:S,Lock:S,Resource:S,ffalse) -> LOCKER2_CHECK_AVAILABLE(Resource:S,Locks:S) CASE8(Tail:S,Head:S,E:S,ffalse) -> DELETE(E:S,Tail:S) CASE9(Tail:S,Head:S,E:S,ffalse) -> MEMBER(E:S,Tail:S) ELEMENT(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> ELEMENT(int(s(N1:S)),T2:S) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> AND(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S)) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> AND(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> EQC(CS1:S,CS2:S) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> EQS(S1:S,S2:S) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> EQT(E1:S,E2:S) EQS(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> AND(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) EQS(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> EQS(S1:S,S2:S) EQS(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> EQT(E1:S,E2:S) EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> AND(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> EQT(H1:S,H2:S) EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> EQT(T1:S,T2:S) EQT(pid(N1:S),pid(N2:S)) -> EQT(N1:S,N2:S) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> AND(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> EQT(H1:S,H2:S) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> EQT(T1:S,T2:S) EQT(tuplenil(H1:S),tuplenil(H2:S)) -> EQT(H1:S,H2:S) ISTOPS(E1:S,stack(E2:S,S1:S)) -> EQT(E1:S,E2:S) LOCKER2_ADD_PENDING(Lock:S,Resources:S,Client:S) -> CASE1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) LOCKER2_ADD_PENDING(Lock:S,Resources:S,Client:S) -> MEMBER(record_extract(Lock:S,lock,resource),Resources:S) LOCKER2_ADD_PENDING(Lock:S,Resources:S,Client:S) -> RECORD_EXTRACT(Lock:S,lock,resource) LOCKER2_CHECK_AVAILABLE(Resource:S,cons(Lock:S,Locks:S)) -> CASE6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) LOCKER2_CHECK_AVAILABLE(Resource:S,cons(Lock:S,Locks:S)) -> RECORD_EXTRACT(Lock:S,lock,resource) LOCKER2_CHECK_AVAILABLES(cons(Resource:S,Resources:S),Locks:S) -> LOCKER2_CHECK_AVAILABLE(Resource:S,Locks:S) LOCKER2_CHECK_AVAILABLES(cons(Resource:S,Resources:S),Locks:S) -> LOCKER2_CHECK_AVAILABLES(Resources:S,Locks:S) LOCKER2_MAP_CLAIM_LOCK(cons(Lock:S,Locks:S),Resources:S,Client:S) -> LOCKER2_MAP_CLAIM_LOCK(Locks:S,Resources:S,Client:S) LOCKER2_MAP_PROMOTE_PENDING(cons(Lock:S,Locks:S),Pending:S) -> LOCKER2_MAP_PROMOTE_PENDING(Locks:S,Pending:S) LOCKER2_MAP_PROMOTE_PENDING(cons(Lock:S,Locks:S),Pending:S) -> LOCKER2_PROMOTE_PENDING(Lock:S,Pending:S) LOCKER2_PROMOTE_PENDING(Lock:S,Client:S) -> CASE0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) LOCKER2_RELEASE_LOCK(Lock:S,Client:S) -> CASE2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) LOCKER2_RELEASE_LOCK(Lock:S,Client:S) -> GEN_MODTAGEQ(Client:S,record_extract(Lock:S,lock,excl)) LOCKER2_REMOVE_PENDING(Lock:S,Client:S) -> RECORD_UPDATES(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) LOCKER2_REMOVE_PENDING(Lock:S,Client:S) -> SUBTRACT(record_extract(Lock:S,lock,pending),cons(Client:S,nil)) PUSH(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> EQT(E1:S,E3:S) PUSH(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> PUSH1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) PUSH1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> PUSHS(E2:S,S1:S) RECORD_UPDATES(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> RECORD_UPDATE(Record:S,Name:S,Field:S,NewF:S) RECORD_UPDATES(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> RECORD_UPDATES(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) SUBTRACT(List:S,cons(Head:S,Tail:S)) -> DELETE(Head:S,List:S) SUBTRACT(List:S,cons(Head:S,Tail:S)) -> SUBTRACT(delete(Head:S,List:S),Tail:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S Problem 1: SCC Processor: -> Pairs: APPEND(cons(Head:S,Tail:S),List:S) -> APPEND(Tail:S,List:S) CASE0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> RECORD_UPDATES(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) CASE1(Client:S,Resources:S,Lock:S,ttrue) -> RECORD_UPDATES(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) CASE5(Client:S,Locks:S,Lock:S,ffalse) -> LOCKER2_OBTAINABLES(Locks:S,Client:S) CASE5(Client:S,Locks:S,Lock:S,ttrue) -> LOCKER2_OBTAINABLES(Locks:S,Client:S) CASE6(Locks:S,Lock:S,Resource:S,ffalse) -> LOCKER2_CHECK_AVAILABLE(Resource:S,Locks:S) CASE8(Tail:S,Head:S,E:S,ffalse) -> DELETE(E:S,Tail:S) CASE9(Tail:S,Head:S,E:S,ffalse) -> MEMBER(E:S,Tail:S) ELEMENT(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> ELEMENT(int(s(N1:S)),T2:S) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> AND(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S)) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> AND(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> EQC(CS1:S,CS2:S) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> EQS(S1:S,S2:S) EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> EQT(E1:S,E2:S) EQS(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> AND(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) EQS(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> EQS(S1:S,S2:S) EQS(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> EQT(E1:S,E2:S) EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> AND(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> EQT(H1:S,H2:S) EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> EQT(T1:S,T2:S) EQT(pid(N1:S),pid(N2:S)) -> EQT(N1:S,N2:S) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> AND(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> EQT(H1:S,H2:S) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> EQT(T1:S,T2:S) EQT(tuplenil(H1:S),tuplenil(H2:S)) -> EQT(H1:S,H2:S) ISTOPS(E1:S,stack(E2:S,S1:S)) -> EQT(E1:S,E2:S) LOCKER2_ADD_PENDING(Lock:S,Resources:S,Client:S) -> CASE1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) LOCKER2_ADD_PENDING(Lock:S,Resources:S,Client:S) -> MEMBER(record_extract(Lock:S,lock,resource),Resources:S) LOCKER2_ADD_PENDING(Lock:S,Resources:S,Client:S) -> RECORD_EXTRACT(Lock:S,lock,resource) LOCKER2_CHECK_AVAILABLE(Resource:S,cons(Lock:S,Locks:S)) -> CASE6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) LOCKER2_CHECK_AVAILABLE(Resource:S,cons(Lock:S,Locks:S)) -> RECORD_EXTRACT(Lock:S,lock,resource) LOCKER2_CHECK_AVAILABLES(cons(Resource:S,Resources:S),Locks:S) -> LOCKER2_CHECK_AVAILABLE(Resource:S,Locks:S) LOCKER2_CHECK_AVAILABLES(cons(Resource:S,Resources:S),Locks:S) -> LOCKER2_CHECK_AVAILABLES(Resources:S,Locks:S) LOCKER2_MAP_CLAIM_LOCK(cons(Lock:S,Locks:S),Resources:S,Client:S) -> LOCKER2_MAP_CLAIM_LOCK(Locks:S,Resources:S,Client:S) LOCKER2_MAP_PROMOTE_PENDING(cons(Lock:S,Locks:S),Pending:S) -> LOCKER2_MAP_PROMOTE_PENDING(Locks:S,Pending:S) LOCKER2_MAP_PROMOTE_PENDING(cons(Lock:S,Locks:S),Pending:S) -> LOCKER2_PROMOTE_PENDING(Lock:S,Pending:S) LOCKER2_PROMOTE_PENDING(Lock:S,Client:S) -> CASE0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) LOCKER2_RELEASE_LOCK(Lock:S,Client:S) -> CASE2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) LOCKER2_RELEASE_LOCK(Lock:S,Client:S) -> GEN_MODTAGEQ(Client:S,record_extract(Lock:S,lock,excl)) LOCKER2_REMOVE_PENDING(Lock:S,Client:S) -> RECORD_UPDATES(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) LOCKER2_REMOVE_PENDING(Lock:S,Client:S) -> SUBTRACT(record_extract(Lock:S,lock,pending),cons(Client:S,nil)) PUSH(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> EQT(E1:S,E3:S) PUSH(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> PUSH1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) PUSH1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> PUSHS(E2:S,S1:S) RECORD_UPDATES(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> RECORD_UPDATE(Record:S,Name:S,Field:S,NewF:S) RECORD_UPDATES(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> RECORD_UPDATES(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) SUBTRACT(List:S,cons(Head:S,Tail:S)) -> DELETE(Head:S,List:S) SUBTRACT(List:S,cons(Head:S,Tail:S)) -> SUBTRACT(delete(Head:S,List:S),Tail:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: SUBTRACT(List:S,cons(Head:S,Tail:S)) -> SUBTRACT(delete(Head:S,List:S),Tail:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: RECORD_UPDATES(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> RECORD_UPDATES(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: LOCKER2_MAP_PROMOTE_PENDING(cons(Lock:S,Locks:S),Pending:S) -> LOCKER2_MAP_PROMOTE_PENDING(Locks:S,Pending:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: LOCKER2_MAP_CLAIM_LOCK(cons(Lock:S,Locks:S),Resources:S,Client:S) -> LOCKER2_MAP_CLAIM_LOCK(Locks:S,Resources:S,Client:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: LOCKER2_CHECK_AVAILABLES(cons(Resource:S,Resources:S),Locks:S) -> LOCKER2_CHECK_AVAILABLES(Resources:S,Locks:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> EQT(H1:S,H2:S) EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> EQT(T1:S,T2:S) EQT(pid(N1:S),pid(N2:S)) -> EQT(N1:S,N2:S) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> EQT(H1:S,H2:S) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> EQT(T1:S,T2:S) EQT(tuplenil(H1:S),tuplenil(H2:S)) -> EQT(H1:S,H2:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: EQS(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> EQS(S1:S,S2:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> EQC(CS1:S,CS2:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: ELEMENT(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> ELEMENT(int(s(N1:S)),T2:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->->Cycle: ->->-> Pairs: APPEND(cons(Head:S,Tail:S),List:S) -> APPEND(Tail:S,List:S) ->->-> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S The problem is decomposed in 10 subproblems. Problem 1.1: Subterm Processor: -> Pairs: SUBTRACT(List:S,cons(Head:S,Tail:S)) -> SUBTRACT(delete(Head:S,List:S),Tail:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(SUBTRACT) = 2 Problem 1.1: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.2: Subterm Processor: -> Pairs: RECORD_UPDATES(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> RECORD_UPDATES(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(RECORD_UPDATES) = 3 Problem 1.2: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.3: Subterm Processor: -> Pairs: LOCKER2_MAP_PROMOTE_PENDING(cons(Lock:S,Locks:S),Pending:S) -> LOCKER2_MAP_PROMOTE_PENDING(Locks:S,Pending:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(LOCKER2_MAP_PROMOTE_PENDING) = 1 Problem 1.3: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.4: Subterm Processor: -> Pairs: LOCKER2_MAP_CLAIM_LOCK(cons(Lock:S,Locks:S),Resources:S,Client:S) -> LOCKER2_MAP_CLAIM_LOCK(Locks:S,Resources:S,Client:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(LOCKER2_MAP_CLAIM_LOCK) = 1 Problem 1.4: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.5: Subterm Processor: -> Pairs: LOCKER2_CHECK_AVAILABLES(cons(Resource:S,Resources:S),Locks:S) -> LOCKER2_CHECK_AVAILABLES(Resources:S,Locks:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(LOCKER2_CHECK_AVAILABLES) = 1 Problem 1.5: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.6: Subterm Processor: -> Pairs: EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> EQT(H1:S,H2:S) EQT(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> EQT(T1:S,T2:S) EQT(pid(N1:S),pid(N2:S)) -> EQT(N1:S,N2:S) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> EQT(H1:S,H2:S) EQT(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> EQT(T1:S,T2:S) EQT(tuplenil(H1:S),tuplenil(H2:S)) -> EQT(H1:S,H2:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(EQT) = 1 Problem 1.6: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.7: Subterm Processor: -> Pairs: EQS(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> EQS(S1:S,S2:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(EQS) = 1 Problem 1.7: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.8: Subterm Processor: -> Pairs: EQC(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> EQC(CS1:S,CS2:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(EQC) = 1 Problem 1.8: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.9: Subterm Processor: -> Pairs: ELEMENT(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> ELEMENT(int(s(N1:S)),T2:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(ELEMENT) = 2 Problem 1.9: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.10: Subterm Processor: -> Pairs: APPEND(cons(Head:S,Tail:S),List:S) -> APPEND(Tail:S,List:S) -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Projection: pi(APPEND) = 1 Problem 1.10: SCC Processor: -> Pairs: Empty -> Rules: and(F,B:S) -> F and(T,B:S) -> B:S and(B:S,F) -> F and(B:S,T) -> B:S append(cons(Head:S,Tail:S),List:S) -> cons(Head:S,append(Tail:S,List:S)) case0(Client:S,Lock:S,cons(Client:S,Pendings:S)) -> record_updates(Lock:S,lock,cons(tuple(excl,tuplenil(Client:S)),cons(tuple(pending,tuplenil(Pendings:S)),nil))) case0(Client:S,Lock:S,MCRLFree0:S) -> Lock:S case1(Client:S,Resources:S,Lock:S,ffalse) -> Lock:S case1(Client:S,Resources:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(append(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) case2(Client:S,Lock:S,ttrue) -> record_updates(Lock:S,lock,cons(tuple(excllock,excl),nil)) case4(Client:S,Lock:S,MCRLFree1:S) -> ffalse case5(Client:S,Locks:S,Lock:S,ffalse) -> locker2_obtainables(Locks:S,Client:S) case5(Client:S,Locks:S,Lock:S,ttrue) -> andt(locker2_obtainable(Lock:S,Client:S),locker2_obtainables(Locks:S,Client:S)) case6(Locks:S,Lock:S,Resource:S,ffalse) -> locker2_check_available(Resource:S,Locks:S) case6(Locks:S,Lock:S,Resource:S,ttrue) -> andt(equal(record_extract(Lock:S,lock,excl),nil),equal(record_extract(Lock:S,lock,pending),nil)) case8(Tail:S,Head:S,E:S,ffalse) -> cons(Head:S,delete(E:S,Tail:S)) case8(Tail:S,Head:S,E:S,ttrue) -> Tail:S case9(Tail:S,Head:S,E:S,ffalse) -> member(E:S,Tail:S) case9(Tail:S,Head:S,E:S,ttrue) -> ttrue delete(E:S,cons(Head:S,Tail:S)) -> case8(Tail:S,Head:S,E:S,equal(E:S,Head:S)) delete(E:S,nil) -> nil element(int(s(0)),tuple(T1:S,T2:S)) -> T1:S element(int(s(0)),tuplenil(T1:S)) -> T1:S element(int(s(s(N1:S))),tuple(T1:S,T2:S)) -> element(int(s(N1:S)),T2:S) eq(F,F) -> T eq(F,T) -> F eq(T,F) -> F eq(T,T) -> T eqc(calls(E1:S,S1:S,CS1:S),calls(E2:S,S2:S,CS2:S)) -> and(eqt(E1:S,E2:S),and(eqs(S1:S,S2:S),eqc(CS1:S,CS2:S))) eqc(calls(E1:S,S1:S,CS1:S),nocalls) -> F eqc(nocalls,calls(E2:S,S2:S,CS2:S)) -> F eqc(nocalls,nocalls) -> T eqs(empty,empty) -> T eqs(empty,stack(E2:S,S2:S)) -> F eqs(stack(E1:S,S1:S),empty) -> F eqs(stack(E1:S,S1:S),stack(E2:S,S2:S)) -> and(eqt(E1:S,E2:S),eqs(S1:S,S2:S)) eqt(a,a) -> T eqt(a,cons(H2:S,T2:S)) -> F eqt(a,excl) -> F eqt(a,ffalse) -> F eqt(a,int(N2:S)) -> F eqt(a,lock) -> F eqt(a,locker) -> F eqt(a,mcrlrecord) -> F eqt(a,nil) -> F eqt(a,ok) -> F eqt(a,pending) -> F eqt(a,pid(N2:S)) -> F eqt(a,release) -> F eqt(a,request) -> F eqt(a,resource) -> F eqt(a,tag) -> F eqt(a,ttrue) -> F eqt(a,tuple(H2:S,T2:S)) -> F eqt(a,tuplenil(H2:S)) -> F eqt(a,undefined) -> F eqt(cons(H1:S,T1:S),cons(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(cons(H1:S,T1:S),int(N2:S)) -> F eqt(cons(H1:S,T1:S),pid(N2:S)) -> F eqt(cons(H1:S,T1:S),resource) -> F eqt(cons(H1:S,T1:S),tag) -> F eqt(cons(H1:S,T1:S),ttrue) -> F eqt(cons(H1:S,T1:S),tuple(H2:S,T2:S)) -> F eqt(cons(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(cons(H1:S,T1:S),undefined) -> F eqt(excl,eqt(ffalse,int(N2:S))) -> F eqt(excl,a) -> F eqt(excl,excl) -> T eqt(excl,ffalse) -> F eqt(excl,lock) -> F eqt(excl,locker) -> F eqt(excl,mcrlrecord) -> F eqt(excl,nil) -> F eqt(excl,ok) -> F eqt(excl,pending) -> F eqt(excl,pid(N2:S)) -> F eqt(excl,release) -> F eqt(excl,request) -> F eqt(excl,resource) -> F eqt(excl,tag) -> F eqt(excl,ttrue) -> F eqt(excl,undefined) -> F eqt(ffalse,cons(H2:S,T2:S)) -> F eqt(ffalse,tuple(H2:S,T2:S)) -> F eqt(ffalse,tuplenil(H2:S)) -> F eqt(int(N1:S),a) -> F eqt(int(N1:S),excl) -> F eqt(int(N1:S),ffalse) -> F eqt(int(N1:S),lock) -> F eqt(int(N1:S),locker) -> F eqt(int(N1:S),mcrlrecord) -> F eqt(int(N1:S),nil) -> F eqt(int(N1:S),ok) -> F eqt(int(N1:S),pending) -> F eqt(int(N1:S),release) -> F eqt(int(N1:S),request) -> F eqt(int(N1:S),resource) -> F eqt(int(N1:S),tag) -> F eqt(int(N1:S),ttrue) -> F eqt(int(N1:S),undefined) -> F eqt(lock,a) -> F eqt(lock,cons(H2:S,T2:S)) -> F eqt(lock,excl) -> F eqt(lock,ffalse) -> F eqt(lock,int(N2:S)) -> F eqt(lock,lock) -> T eqt(lock,locker) -> F eqt(lock,mcrlrecord) -> F eqt(lock,nil) -> F eqt(lock,ok) -> F eqt(lock,pending) -> F eqt(lock,pid(N2:S)) -> F eqt(lock,release) -> F eqt(lock,request) -> F eqt(lock,resource) -> F eqt(lock,tag) -> F eqt(lock,ttrue) -> F eqt(lock,tuple(H2:S,T2:S)) -> F eqt(lock,tuplenil(H2:S)) -> F eqt(lock,undefined) -> F eqt(locker,a) -> F eqt(locker,cons(H2:S,T2:S)) -> F eqt(locker,excl) -> F eqt(locker,ffalse) -> F eqt(locker,int(N2:S)) -> F eqt(locker,lock) -> F eqt(locker,locker) -> T eqt(locker,mcrlrecord) -> F eqt(locker,nil) -> F eqt(locker,ok) -> F eqt(locker,pending) -> F eqt(locker,pid(N2:S)) -> F eqt(locker,release) -> F eqt(locker,request) -> F eqt(locker,resource) -> F eqt(locker,tag) -> F eqt(locker,ttrue) -> F eqt(locker,tuple(H2:S,T2:S)) -> F eqt(locker,tuplenil(H2:S)) -> F eqt(locker,undefined) -> F eqt(mcrlrecord,a) -> F eqt(mcrlrecord,excl) -> F eqt(mcrlrecord,ffalse) -> F eqt(mcrlrecord,lock) -> F eqt(mcrlrecord,locker) -> F eqt(mcrlrecord,mcrlrecord) -> T eqt(mcrlrecord,nil) -> F eqt(mcrlrecord,ok) -> F eqt(mcrlrecord,pending) -> F eqt(mcrlrecord,release) -> F eqt(mcrlrecord,request) -> F eqt(mcrlrecord,resource) -> F eqt(nil,cons(H2:S,T2:S)) -> F eqt(nil,int(N2:S)) -> F eqt(nil,pid(N2:S)) -> F eqt(nil,tuple(H2:S,T2:S)) -> F eqt(nil,tuplenil(H2:S)) -> F eqt(nil,undefined) -> F eqt(ok,cons(H2:S,T2:S)) -> F eqt(ok,int(N2:S)) -> F eqt(ok,pid(N2:S)) -> F eqt(ok,resource) -> F eqt(ok,tag) -> F eqt(ok,ttrue) -> F eqt(ok,tuple(H2:S,T2:S)) -> F eqt(ok,tuplenil(H2:S)) -> F eqt(ok,undefined) -> F eqt(pending,a) -> F eqt(pending,cons(H2:S,T2:S)) -> F eqt(pending,excl) -> F eqt(pending,ffalse) -> F eqt(pending,int(N2:S)) -> F eqt(pending,lock) -> F eqt(pending,locker) -> F eqt(pending,mcrlrecord) -> F eqt(pending,nil) -> F eqt(pending,ok) -> F eqt(pending,pending) -> T eqt(pending,pid(N2:S)) -> F eqt(pending,release) -> F eqt(pending,request) -> F eqt(pending,resource) -> F eqt(pending,tag) -> F eqt(pending,ttrue) -> F eqt(pending,tuple(H2:S,T2:S)) -> F eqt(pending,tuplenil(H2:S)) -> F eqt(pending,undefined) -> F eqt(pid(N1:S),a) -> F eqt(pid(N1:S),cons(H2:S,T2:S)) -> F eqt(pid(N1:S),excl) -> F eqt(pid(N1:S),ffalse) -> F eqt(pid(N1:S),int(N2:S)) -> F eqt(pid(N1:S),lock) -> F eqt(pid(N1:S),locker) -> F eqt(pid(N1:S),mcrlrecord) -> F eqt(pid(N1:S),nil) -> F eqt(pid(N1:S),ok) -> F eqt(pid(N1:S),pending) -> F eqt(pid(N1:S),pid(N2:S)) -> eqt(N1:S,N2:S) eqt(pid(N1:S),release) -> F eqt(pid(N1:S),request) -> F eqt(pid(N1:S),resource) -> F eqt(pid(N1:S),tag) -> F eqt(pid(N1:S),ttrue) -> F eqt(pid(N1:S),tuple(H2:S,T2:S)) -> F eqt(pid(N1:S),tuplenil(H2:S)) -> F eqt(pid(N1:S),undefined) -> F eqt(release,a) -> F eqt(release,excl) -> F eqt(release,ffalse) -> F eqt(release,lock) -> F eqt(release,locker) -> F eqt(release,mcrlrecord) -> F eqt(release,nil) -> F eqt(release,ok) -> F eqt(request,cons(H2:S,T2:S)) -> F eqt(request,int(N2:S)) -> F eqt(request,mcrlrecord) -> F eqt(request,ok) -> F eqt(request,pending) -> F eqt(request,pid(N2:S)) -> F eqt(request,release) -> F eqt(request,request) -> T eqt(request,resource) -> F eqt(request,tag) -> F eqt(request,ttrue) -> F eqt(request,tuple(H2:S,T2:S)) -> F eqt(request,tuplenil(H2:S)) -> F eqt(request,undefined) -> F eqt(resource,a) -> F eqt(resource,cons(H2:S,T2:S)) -> F eqt(resource,excl) -> F eqt(resource,ffalse) -> F eqt(resource,int(N2:S)) -> F eqt(resource,lock) -> F eqt(resource,locker) -> F eqt(resource,mcrlrecord) -> F eqt(resource,nil) -> F eqt(resource,ok) -> F eqt(resource,pending) -> F eqt(resource,pid(N2:S)) -> F eqt(resource,release) -> F eqt(resource,request) -> F eqt(resource,resource) -> T eqt(resource,tag) -> F eqt(resource,ttrue) -> F eqt(resource,tuple(H2:S,T2:S)) -> F eqt(resource,tuplenil(H2:S)) -> F eqt(resource,undefined) -> F eqt(tag,a) -> F eqt(tag,cons(H2:S,T2:S)) -> F eqt(tag,excl) -> F eqt(tag,ffalse) -> F eqt(tag,int(N2:S)) -> F eqt(tag,lock) -> F eqt(tag,locker) -> F eqt(tag,mcrlrecord) -> F eqt(tag,nil) -> F eqt(tag,ok) -> F eqt(tag,pending) -> F eqt(tag,pid(N2:S)) -> F eqt(tag,release) -> F eqt(tag,request) -> F eqt(tag,resource) -> F eqt(tag,tag) -> T eqt(tag,ttrue) -> F eqt(tag,tuple(H2:S,T2:S)) -> F eqt(tag,tuplenil(H2:S)) -> F eqt(tag,undefined) -> F eqt(ttrue,a) -> F eqt(ttrue,cons(H2:S,T2:S)) -> F eqt(ttrue,excl) -> F eqt(ttrue,ffalse) -> F eqt(ttrue,int(N2:S)) -> F eqt(ttrue,lock) -> F eqt(ttrue,locker) -> F eqt(ttrue,mcrlrecord) -> F eqt(ttrue,nil) -> F eqt(ttrue,ok) -> F eqt(ttrue,pending) -> F eqt(ttrue,pid(N2:S)) -> F eqt(ttrue,release) -> F eqt(ttrue,request) -> F eqt(ttrue,resource) -> F eqt(ttrue,tag) -> F eqt(ttrue,ttrue) -> T eqt(ttrue,tuple(H2:S,T2:S)) -> F eqt(ttrue,tuplenil(H2:S)) -> F eqt(ttrue,undefined) -> F eqt(tuple(H1:S,T1:S),a) -> F eqt(tuple(H1:S,T1:S),cons(H2:S,T2:S)) -> F eqt(tuple(H1:S,T1:S),excl) -> F eqt(tuple(H1:S,T1:S),ffalse) -> F eqt(tuple(H1:S,T1:S),int(N2:S)) -> F eqt(tuple(H1:S,T1:S),lock) -> F eqt(tuple(H1:S,T1:S),locker) -> F eqt(tuple(H1:S,T1:S),mcrlrecord) -> F eqt(tuple(H1:S,T1:S),nil) -> F eqt(tuple(H1:S,T1:S),ok) -> F eqt(tuple(H1:S,T1:S),pending) -> F eqt(tuple(H1:S,T1:S),pid(N2:S)) -> F eqt(tuple(H1:S,T1:S),release) -> F eqt(tuple(H1:S,T1:S),request) -> F eqt(tuple(H1:S,T1:S),resource) -> F eqt(tuple(H1:S,T1:S),tag) -> F eqt(tuple(H1:S,T1:S),ttrue) -> F eqt(tuple(H1:S,T1:S),tuple(H2:S,T2:S)) -> and(eqt(H1:S,H2:S),eqt(T1:S,T2:S)) eqt(tuple(H1:S,T1:S),tuplenil(H2:S)) -> F eqt(tuple(H1:S,T1:S),undefined) -> F eqt(tuplenil(H1:S),a) -> F eqt(tuplenil(H1:S),cons(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),excl) -> F eqt(tuplenil(H1:S),ffalse) -> F eqt(tuplenil(H1:S),int(N2:S)) -> F eqt(tuplenil(H1:S),lock) -> F eqt(tuplenil(H1:S),locker) -> F eqt(tuplenil(H1:S),mcrlrecord) -> F eqt(tuplenil(H1:S),nil) -> F eqt(tuplenil(H1:S),ok) -> F eqt(tuplenil(H1:S),pending) -> F eqt(tuplenil(H1:S),pid(N2:S)) -> F eqt(tuplenil(H1:S),release) -> F eqt(tuplenil(H1:S),request) -> F eqt(tuplenil(H1:S),resource) -> F eqt(tuplenil(H1:S),tag) -> F eqt(tuplenil(H1:S),ttrue) -> F eqt(tuplenil(H1:S),tuple(H2:S,T2:S)) -> F eqt(tuplenil(H1:S),tuplenil(H2:S)) -> eqt(H1:S,H2:S) eqt(tuplenil(H1:S),undefined) -> F eqt(undefined,a) -> F eqt(undefined,nil) -> F eqt(undefined,tuplenil(H2:S)) -> F gen_modtageq(Client1:S,Client2:S) -> equal(Client1:S,Client2:S) gen_tag(Pid:S) -> tuple(Pid:S,tuplenil(tag)) if(F,B1:S,B2:S) -> B2:S if(T,B1:S,B2:S) -> B1:S imp(F,B:S) -> T imp(T,B:S) -> B:S istops(E1:S,empty) -> F istops(E1:S,stack(E2:S,S1:S)) -> eqt(E1:S,E2:S) locker2_add_pending(Lock:S,Resources:S,Client:S) -> case1(Client:S,Resources:S,Lock:S,member(record_extract(Lock:S,lock,resource),Resources:S)) locker2_adduniq(nil,List:S) -> List:S locker2_check_available(Resource:S,cons(Lock:S,Locks:S)) -> case6(Locks:S,Lock:S,Resource:S,equal(Resource:S,record_extract(Lock:S,lock,resource))) locker2_check_available(Resource:S,nil) -> ffalse locker2_check_availables(cons(Resource:S,Resources:S),Locks:S) -> andt(locker2_check_available(Resource:S,Locks:S),locker2_check_availables(Resources:S,Locks:S)) locker2_check_availables(nil,Locks:S) -> ttrue locker2_map_add_pending(nil,Resources:S,Client:S) -> nil locker2_map_claim_lock(cons(Lock:S,Locks:S),Resources:S,Client:S) -> cons(locker2_claim_lock(Lock:S,Resources:S,Client:S),locker2_map_claim_lock(Locks:S,Resources:S,Client:S)) locker2_map_claim_lock(nil,Resources:S,Client:S) -> nil locker2_map_promote_pending(cons(Lock:S,Locks:S),Pending:S) -> cons(locker2_promote_pending(Lock:S,Pending:S),locker2_map_promote_pending(Locks:S,Pending:S)) locker2_map_promote_pending(nil,Pending:S) -> nil locker2_obtainables(cons(Lock:S,Locks:S),Client:S) -> case5(Client:S,Locks:S,Lock:S,member(Client:S,record_extract(Lock:S,lock,pending))) locker2_obtainables(nil,Client:S) -> ttrue locker2_promote_pending(Lock:S,Client:S) -> case0(Client:S,Lock:S,record_extract(Lock:S,lock,pending)) locker2_release_lock(Lock:S,Client:S) -> case2(Client:S,Lock:S,gen_modtageq(Client:S,record_extract(Lock:S,lock,excl))) locker2_remove_pending(Lock:S,Client:S) -> record_updates(Lock:S,lock,cons(tuple(pending,tuplenil(subtract(record_extract(Lock:S,lock,pending),cons(Client:S,nil)))),nil)) member(E:S,cons(Head:S,Tail:S)) -> case9(Tail:S,Head:S,E:S,equal(E:S,Head:S)) member(E:S,nil) -> ffalse not(F) -> T not(T) -> F or(F,F) -> F or(F,T) -> T or(T,F) -> T or(T,T) -> T pops(stack(E1:S,S1:S)) -> S1:S push(E1:S,E2:S,calls(E3:S,S1:S,CS1:S)) -> push1(E1:S,E2:S,E3:S,S1:S,CS1:S,eqt(E1:S,E3:S)) push(E1:S,E2:S,nocalls) -> calls(E1:S,stack(E2:S,empty),nocalls) push1(E1:S,E2:S,E3:S,S1:S,CS1:S,T) -> calls(E3:S,pushs(E2:S,S1:S),CS1:S) pushs(E1:S,S1:S) -> stack(E1:S,S1:S) record_extract(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,resource) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))) record_new(lock) -> tuple(mcrlrecord,tuple(lock,tuple(undefined,tuple(nil,tuplenil(nil))))) record_update(tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(F2:S))))),lock,pending,NewF:S) -> tuple(mcrlrecord,tuple(lock,tuple(F0:S,tuple(F1:S,tuplenil(NewF:S))))) record_updates(Record:S,Name:S,cons(tuple(Field:S,tuplenil(NewF:S)),Fields:S)) -> record_updates(record_update(Record:S,Name:S,Field:S,NewF:S),Name:S,Fields:S) record_updates(Record:S,Name:S,nil) -> Record:S subtract(List:S,cons(Head:S,Tail:S)) -> subtract(delete(Head:S,List:S),Tail:S) subtract(List:S,nil) -> List:S tops(stack(E1:S,S1:S)) -> E1:S ->Strongly Connected Components: There is no strongly connected component The problem is finite.