Runtime Complexity (innermost) proof of /tmp/tmpoLMP0X/mucrl1.xml

The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, n^1).

0 CpxTRS

↳1 NestedDefinedSymbolProof (BOTH BOUNDS(ID, ID), 0 ms)

↳2 CpxTRS

↳3 CpxTrsToCdtProof (BOTH BOUNDS(ID, ID), 136 ms)

↳4 CdtProblem

↳5 CdtLeafRemovalProof (ComplexityIfPolyImplication, 0 ms)

↳6 CdtProblem

↳7 CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID), 0 ms)

↳8 CdtProblem

↳9 CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID), 0 ms)

↳10 CdtProblem

↳11 CdtLeafRemovalProof (ComplexityIfPolyImplication, 0 ms)

↳12 CdtProblem

↳13 CdtKnowledgeProof (BOTH BOUNDS(ID, ID), 0 ms)

↳14 CdtProblem

↳15 CdtUsableRulesProof (⇔, 7 ms)

↳16 CdtProblem

↳17 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 236 ms)

↳18 CdtProblem

↳19 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 92 ms)

↳20 CdtProblem

↳21 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 88 ms)

↳22 CdtProblem

↳23 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 63 ms)

↳24 CdtProblem

↳25 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 79 ms)

↳26 CdtProblem

↳27 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 52 ms)

↳28 CdtProblem

↳29 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 68 ms)

↳30 CdtProblem

↳31 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 28 ms)

↳32 CdtProblem

↳33 CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)), 54 ms)

↳34 CdtProblem

↳35 SIsEmptyProof (BOTH BOUNDS(ID, ID), 0 ms)

↳36 BOUNDS(1, 1)

(0) Obligation:

The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, n^1).

The TRS R consists of the following rules:

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

Rewrite Strategy: INNERMOST

(1) NestedDefinedSymbolProof (BOTH BOUNDS(ID, ID) transformation)

The following defined symbols can occur below the 2th argument of case2: gen_modtageq, record_extract
The following defined symbols can occur below the 1th argument of gen_modtageq: record_extract
The following defined symbols can occur below the 0th argument of record_updates: record_update, case8, subtract, delete, record_extract, append
The following defined symbols can occur below the 2th argument of record_updates: case8, subtract, delete, record_extract, append
The following defined symbols can occur below the 0th argument of record_update: record_update
The following defined symbols can occur below the 2th argument of record_update: case8, subtract, delete, record_extract, append
The following defined symbols can occur below the 3th argument of record_update: case8, subtract, delete, record_extract, append
The following defined symbols can occur below the 0th argument of member: record_extract
The following defined symbols can occur below the 1th argument of member: record_extract
The following defined symbols can occur below the 3th argument of case6: record_extract
The following defined symbols can occur below the 0th argument of and: eqt, and, eqs
The following defined symbols can occur below the 1th argument of and: eqt, eqc, eqs, and
The following defined symbols can occur below the 0th argument of subtract: case8, delete, record_extract
The following defined symbols can occur below the 1th argument of delete: case8, delete, record_extract
The following defined symbols can occur below the 2th argument of case0: record_extract
The following defined symbols can occur below the 3th argument of case1: case9, member, record_extract
The following defined symbols can occur below the 0th argument of case9: record_extract
The following defined symbols can occur below the 1th argument of case9: record_extract
The following defined symbols can occur below the 2th argument of case9: record_extract
The following defined symbols can occur below the 3th argument of case9: record_extract
The following defined symbols can occur below the 3th argument of case5: case9, member, record_extract
The following defined symbols can occur below the 0th argument of append: record_extract
The following defined symbols can occur below the 5th argument of push1: eqt, and

Hence, the left-hand sides of the following rules are not basic-reachable and can be removed:
eqt(excl, eqt(false, int(N2))) → F

(2) Obligation:

The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, n^1).

The TRS R consists of the following rules:

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

Rewrite Strategy: INNERMOST

(3) CpxTrsToCdtProof (BOTH BOUNDS(ID, ID) transformation)

Converted Cpx (relative) TRS to CDT

(4) Obligation:

Complexity Dependency Tuples Problem
Rules:

eqt(locker, release) → F
eqt(release, locker) → F
eqt(mcrlrecord, release) → F
eqt(release, mcrlrecord) → F
eqt(pending, undefined) → F
eqt(release, false) → F
eqt(a, int(z0)) → F
eqt(int(z0), a) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tuple(z0, z1), tag) → F
eqt(request, undefined) → F
eqt(a, a) → T
eqt(false, tuplenil(z0)) → F
eqt(lock, resource) → F
eqt(resource, lock) → F
eqt(tuplenil(z0), false) → F
eqt(excl, tag) → F
eqt(lock, ok) → F
eqt(tag, excl) → F
eqt(a, resource) → F
eqt(resource, a) → F
eqt(pending, pid(z0)) → F
eqt(pid(z0), pending) → F
eqt(pending, pending) → T
eqt(request, request) → T
eqt(excl, lock) → F
eqt(lock, excl) → F
eqt(a, nil) → F
eqt(pending, true) → F
eqt(true, pending) → F
eqt(tuple(z0, z1), excl) → F
eqt(nil, pid(z0)) → F
eqt(pid(z0), nil) → F
eqt(lock, cons(z0, z1)) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(ok, tuple(z0, z1)) → F
eqt(tuple(z0, z1), ok) → F
eqt(lock, int(z0)) → F
eqt(locker, pending) → F
eqt(pending, locker) → F
eqt(true, release) → F
eqt(int(z0), lock) → F
eqt(mcrlrecord, request) → F
eqt(request, mcrlrecord) → F
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(excl, ok) → F
eqt(undefined, tuplenil(z0)) → F
eqt(tuplenil(z0), undefined) → F
eqt(int(z0), undefined) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuplenil(z0), release) → F
eqt(a, request) → F
eqt(resource, undefined) → F
eqt(lock, request) → F
eqt(pid(z0), int(z1)) → F
eqt(mcrlrecord, nil) → F
eqt(tag, cons(z0, z1)) → F
eqt(cons(z0, z1), tag) → F
eqt(locker, nil) → F
eqt(a, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(pid(z0), release) → F
eqt(tuple(z0, z1), lock) → F
eqt(true, nil) → F
eqt(a, release) → F
eqt(release, a) → F
eqt(mcrlrecord, false) → F
eqt(request, pid(z0)) → F
eqt(pid(z0), request) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
eqt(a, tag) → F
eqt(tag, a) → F
eqt(pending, release) → F
eqt(pid(z0), false) → F
eqt(ok, pid(z0)) → F
eqt(pid(z0), ok) → F
eqt(excl, undefined) → F
eqt(true, cons(z0, z1)) → F
eqt(cons(z0, z1), true) → F
eqt(pending, tuplenil(z0)) → F
eqt(tuplenil(z0), pending) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(locker, resource) → F
eqt(ok, resource) → F
eqt(resource, locker) → F
eqt(resource, ok) → F
eqt(pending, tag) → F
eqt(tag, pending) → F
eqt(a, lock) → F
eqt(lock, a) → F
eqt(request, tuple(z0, z1)) → F
eqt(tuple(z0, z1), request) → F
eqt(lock, release) → F
eqt(release, lock) → F
eqt(tag, tag) → T
eqt(resource, cons(z0, z1)) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), undefined) → F
eqt(lock, tag) → F
eqt(tag, lock) → F
eqt(release, nil) → F
eqt(locker, pid(z0)) → F
eqt(pid(z0), locker) → F
eqt(tag, nil) → F
eqt(ok, true) → F
eqt(true, ok) → F
eqt(lock, pending) → F
eqt(locker, false) → F
eqt(pending, lock) → F
eqt(a, tuple(z0, z1)) → F
eqt(locker, int(z0)) → F
eqt(int(z0), locker) → F
eqt(tuple(z0, z1), a) → F
eqt(lock, nil) → F
eqt(lock, lock) → T
eqt(a, locker) → F
eqt(a, pending) → F
eqt(locker, a) → F
eqt(pending, a) → F
eqt(true, tuple(z0, z1)) → F
eqt(tuple(z0, z1), true) → F
eqt(pending, request) → F
eqt(request, pending) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(a, ok) → F
eqt(request, ok) → F
eqt(locker, mcrlrecord) → F
eqt(mcrlrecord, locker) → F
eqt(mcrlrecord, ok) → F
eqt(pending, false) → F
eqt(locker, request) → F
eqt(ok, tag) → F
eqt(tag, ok) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(resource, tuple(z0, z1)) → F
eqt(tuple(z0, z1), resource) → F
eqt(locker, true) → F
eqt(true, locker) → F
eqt(mcrlrecord, pending) → F
eqt(pending, mcrlrecord) → F
eqt(locker, tuplenil(z0)) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), excl) → F
eqt(a, undefined) → F
eqt(undefined, a) → F
eqt(release, ok) → F
eqt(request, int(z0)) → F
eqt(int(z0), request) → F
eqt(locker, locker) → T
eqt(lock, true) → F
eqt(true, lock) → F
eqt(lock, mcrlrecord) → F
eqt(mcrlrecord, lock) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, int(z0)) → F
eqt(int(z0), pending) → F
eqt(tag, false) → F
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(pending, nil) → F
eqt(tag, true) → F
eqt(true, tag) → F
eqt(lock, locker) → F
eqt(locker, lock) → F
eqt(resource, release) → F
eqt(excl, excl) → T
eqt(nil, int(z0)) → F
eqt(int(z0), nil) → F
eqt(ok, tuplenil(z0)) → F
eqt(tuplenil(z0), ok) → F
eqt(a, true) → F
eqt(true, a) → F
eqt(locker, tag) → F
eqt(tag, locker) → F
eqt(tuple(z0, z1), release) → F
eqt(lock, pid(z0)) → F
eqt(true, true) → T
eqt(pid(z0), lock) → F
eqt(pending, resource) → F
eqt(resource, pending) → F
eqt(lock, false) → F
eqt(resource, nil) → F
eqt(excl, locker) → F
eqt(locker, excl) → F
eqt(tag, pid(z0)) → F
eqt(pid(z0), tag) → F
eqt(a, false) → F
eqt(pending, ok) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(locker, ok) → F
eqt(tag, tuplenil(z0)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuplenil(z0), tag) → F
eqt(a, mcrlrecord) → F
eqt(mcrlrecord, a) → F
eqt(false, tuple(z0, z1)) → F
eqt(tuple(z0, z1), false) → F
eqt(excl, pending) → F
eqt(pending, excl) → F
eqt(nil, tuplenil(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(tuplenil(z0), nil) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tag, mcrlrecord) → F
eqt(ok, int(z0)) → F
eqt(int(z0), ok) → F
eqt(tuple(z0, z1), undefined) → F
eqt(request, release) → F
eqt(mcrlrecord, mcrlrecord) → T
eqt(a, pid(z0)) → F
eqt(tag, release) → F
eqt(pid(z0), a) → F
eqt(nil, tuple(z0, z1)) → F
eqt(tuple(z0, z1), nil) → F
eqt(request, tag) → F
eqt(tag, request) → F
eqt(true, undefined) → F
eqt(lock, tuplenil(z0)) → F
eqt(tuplenil(z0), lock) → F
eqt(pid(z0), mcrlrecord) → F
eqt(a, tuplenil(z0)) → F
eqt(tuplenil(z0), a) → F
eqt(request, tuplenil(z0)) → F
eqt(tuplenil(z0), request) → F
eqt(locker, undefined) → F
eqt(resource, true) → F
eqt(true, resource) → F
eqt(ok, cons(z0, z1)) → F
eqt(true, pid(z0)) → F
eqt(pid(z0), true) → F
eqt(excl, pid(z0)) → F
eqt(mcrlrecord, resource) → F
eqt(resource, mcrlrecord) → F
eqt(pid(z0), excl) → F
eqt(int(z0), false) → F
eqt(false, cons(z0, z1)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(int(z0), excl) → F
eqt(true, false) → F
eqt(true, mcrlrecord) → F
eqt(resource, pid(z0)) → F
eqt(pid(z0), resource) → F
eqt(excl, resource) → F
eqt(resource, excl) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(true, int(z0)) → F
eqt(int(z0), true) → F
eqt(resource, int(z0)) → F
eqt(int(z0), resource) → F
eqt(excl, nil) → F
eqt(tag, undefined) → F
eqt(ok, undefined) → F
eqt(resource, false) → F
eqt(locker, cons(z0, z1)) → F
eqt(excl, mcrlrecord) → F
eqt(mcrlrecord, excl) → F
eqt(request, true) → F
eqt(true, request) → F
eqt(nil, cons(z0, z1)) → F
eqt(resource, tag) → F
eqt(tag, resource) → F
eqt(pid(z0), undefined) → F
eqt(int(z0), release) → F
eqt(excl, true) → F
eqt(resource, resource) → T
eqt(true, excl) → F
eqt(pending, tuple(z0, z1)) → F
eqt(tuple(z0, z1), pending) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tag, int(z0)) → F
eqt(int(z0), tag) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(excl, false) → F
eqt(request, resource) → F
eqt(resource, request) → F
eqt(nil, undefined) → F
eqt(undefined, nil) → F
eqt(lock, undefined) → F
eqt(true, tuplenil(z0)) → F
eqt(tuplenil(z0), true) → F
eqt(locker, tuple(z0, z1)) → F
eqt(tuple(z0, z1), locker) → F
eqt(resource, tuplenil(z0)) → F
eqt(tuplenil(z0), resource) → F
eqt(excl, release) → F
eqt(release, excl) → F
eqt(a, excl) → F
eqt(excl, a) → F
eqt(int(z0), mcrlrecord) → F
eqt(excl, request) → F
locker2_map_add_pending(nil, z0, z1) → nil
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
record_updates(z0, z1, nil) → z0
record_updates(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → record_updates(record_update(z0, z1, z2, z3), z1, z4)
gen_tag(z0) → tuple(z0, tuplenil(tag))
istops(z0, stack(z1, z2)) → eqt(z0, z1)
istops(z0, empty) → F
locker2_map_promote_pending(nil, z0) → nil
locker2_map_promote_pending(cons(z0, z1), z2) → cons(locker2_promote_pending(z0, z2), locker2_map_promote_pending(z1, z2))
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(0)), tuplenil(z0)) → z0
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
case0(z0, z1, z2) → z1
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(empty, empty) → T
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
locker2_map_claim_lock(nil, z0, z1) → nil
locker2_map_claim_lock(cons(z0, z1), z2, z3) → cons(locker2_claim_lock(z0, z2, z3), locker2_map_claim_lock(z1, z2, z3))
case1(z0, z1, z2, false) → z2
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
locker2_adduniq(nil, z0) → z0
case6(z0, z1, z2, true) → andt(equal(record_extract(z1, lock, excl), nil), equal(record_extract(z1, lock, pending), nil))
case6(z0, z1, z2, false) → locker2_check_available(z2, z0)
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
case5(z0, z1, z2, true) → andt(locker2_obtainable(z2, z0), locker2_obtainables(z1, z0))
case5(z0, z1, z2, false) → locker2_obtainables(z1, z0)
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_check_availables(nil, z0) → true
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
case8(z0, z1, z2, true) → z0
eqc(nocalls, nocalls) → T
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
or(F, F) → F
or(F, T) → T
or(T, F) → T
or(T, T) → T
imp(F, z0) → T
imp(T, z0) → z0
gen_modtageq(z0, z1) → equal(z0, z1)
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
eq(F, F) → T
eq(T, T) → T
eq(T, F) → F
eq(F, T) → F
locker2_check_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
pushs(z0, z1) → stack(z0, z1)
case4(z0, z1, z2) → false
if(T, z0, z1) → z0
if(F, z0, z1) → z1
not(F) → T
not(T) → F
tops(stack(z0, z1)) → z0
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
pops(stack(z0, z1)) → z1
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))

Tuples:

EQT(locker, release) → c
EQT(release, locker) → c1
EQT(mcrlrecord, release) → c2
EQT(release, mcrlrecord) → c3
EQT(pending, undefined) → c4
EQT(release, false) → c5
EQT(a, int(z0)) → c6
EQT(int(z0), a) → c7
EQT(tag, tuple(z0, z1)) → c8
EQT(tuple(z0, z1), tag) → c9
EQT(request, undefined) → c10
EQT(a, a) → c11
EQT(false, tuplenil(z0)) → c12
EQT(lock, resource) → c13
EQT(resource, lock) → c14
EQT(tuplenil(z0), false) → c15
EQT(excl, tag) → c16
EQT(lock, ok) → c17
EQT(tag, excl) → c18
EQT(a, resource) → c19
EQT(resource, a) → c20
EQT(pending, pid(z0)) → c21
EQT(pid(z0), pending) → c22
EQT(pending, pending) → c23
EQT(request, request) → c24
EQT(excl, lock) → c25
EQT(lock, excl) → c26
EQT(a, nil) → c27
EQT(pending, true) → c28
EQT(true, pending) → c29
EQT(tuple(z0, z1), excl) → c30
EQT(nil, pid(z0)) → c31
EQT(pid(z0), nil) → c32
EQT(lock, cons(z0, z1)) → c33
EQT(tuplenil(z0), mcrlrecord) → c34
EQT(ok, tuple(z0, z1)) → c35
EQT(tuple(z0, z1), ok) → c36
EQT(lock, int(z0)) → c37
EQT(locker, pending) → c38
EQT(pending, locker) → c39
EQT(true, release) → c40
EQT(int(z0), lock) → c41
EQT(mcrlrecord, request) → c42
EQT(request, mcrlrecord) → c43
EQT(cons(z0, z1), tuple(z2, z3)) → c44
EQT(tuple(z0, z1), cons(z2, z3)) → c45
EQT(excl, ok) → c46
EQT(undefined, tuplenil(z0)) → c47
EQT(tuplenil(z0), undefined) → c48
EQT(int(z0), undefined) → c49
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), release) → c51
EQT(a, request) → c52
EQT(resource, undefined) → c53
EQT(lock, request) → c54
EQT(pid(z0), int(z1)) → c55
EQT(mcrlrecord, nil) → c56
EQT(tag, cons(z0, z1)) → c57
EQT(cons(z0, z1), tag) → c58
EQT(locker, nil) → c59
EQT(a, cons(z0, z1)) → c60
EQT(lock, tuple(z0, z1)) → c61
EQT(pid(z0), release) → c62
EQT(tuple(z0, z1), lock) → c63
EQT(true, nil) → c64
EQT(a, release) → c65
EQT(release, a) → c66
EQT(mcrlrecord, false) → c67
EQT(request, pid(z0)) → c68
EQT(pid(z0), request) → c69
EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(a, tag) → c71
EQT(tag, a) → c72
EQT(pending, release) → c73
EQT(pid(z0), false) → c74
EQT(ok, pid(z0)) → c75
EQT(pid(z0), ok) → c76
EQT(excl, undefined) → c77
EQT(true, cons(z0, z1)) → c78
EQT(cons(z0, z1), true) → c79
EQT(pending, tuplenil(z0)) → c80
EQT(tuplenil(z0), pending) → c81
EQT(pid(z0), cons(z1, z2)) → c82
EQT(cons(z0, z1), pid(z2)) → c83
EQT(locker, resource) → c84
EQT(ok, resource) → c85
EQT(resource, locker) → c86
EQT(resource, ok) → c87
EQT(pending, tag) → c88
EQT(tag, pending) → c89
EQT(a, lock) → c90
EQT(lock, a) → c91
EQT(request, tuple(z0, z1)) → c92
EQT(tuple(z0, z1), request) → c93
EQT(lock, release) → c94
EQT(release, lock) → c95
EQT(tag, tag) → c96
EQT(resource, cons(z0, z1)) → c97
EQT(cons(z0, z1), resource) → c98
EQT(cons(z0, z1), undefined) → c99
EQT(lock, tag) → c100
EQT(tag, lock) → c101
EQT(release, nil) → c102
EQT(locker, pid(z0)) → c103
EQT(pid(z0), locker) → c104
EQT(tag, nil) → c105
EQT(ok, true) → c106
EQT(true, ok) → c107
EQT(lock, pending) → c108
EQT(locker, false) → c109
EQT(pending, lock) → c110
EQT(a, tuple(z0, z1)) → c111
EQT(locker, int(z0)) → c112
EQT(int(z0), locker) → c113
EQT(tuple(z0, z1), a) → c114
EQT(lock, nil) → c115
EQT(lock, lock) → c116
EQT(a, locker) → c117
EQT(a, pending) → c118
EQT(locker, a) → c119
EQT(pending, a) → c120
EQT(true, tuple(z0, z1)) → c121
EQT(tuple(z0, z1), true) → c122
EQT(pending, request) → c123
EQT(request, pending) → c124
EQT(tuple(z0, z1), mcrlrecord) → c125
EQT(a, ok) → c126
EQT(request, ok) → c127
EQT(locker, mcrlrecord) → c128
EQT(mcrlrecord, locker) → c129
EQT(mcrlrecord, ok) → c130
EQT(pending, false) → c131
EQT(locker, request) → c132
EQT(ok, tag) → c133
EQT(tag, ok) → c134
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(resource, tuple(z0, z1)) → c136
EQT(tuple(z0, z1), resource) → c137
EQT(locker, true) → c138
EQT(true, locker) → c139
EQT(mcrlrecord, pending) → c140
EQT(pending, mcrlrecord) → c141
EQT(locker, tuplenil(z0)) → c142
EQT(tuplenil(z0), locker) → c143
EQT(tuplenil(z0), excl) → c144
EQT(a, undefined) → c145
EQT(undefined, a) → c146
EQT(release, ok) → c147
EQT(request, int(z0)) → c148
EQT(int(z0), request) → c149
EQT(locker, locker) → c150
EQT(lock, true) → c151
EQT(true, lock) → c152
EQT(lock, mcrlrecord) → c153
EQT(mcrlrecord, lock) → c154
EQT(pending, cons(z0, z1)) → c155
EQT(pending, int(z0)) → c156
EQT(int(z0), pending) → c157
EQT(tag, false) → c158
EQT(tuple(z0, z1), tuplenil(z2)) → c159
EQT(tuplenil(z0), tuple(z1, z2)) → c160
EQT(pending, nil) → c161
EQT(tag, true) → c162
EQT(true, tag) → c163
EQT(lock, locker) → c164
EQT(locker, lock) → c165
EQT(resource, release) → c166
EQT(excl, excl) → c167
EQT(nil, int(z0)) → c168
EQT(int(z0), nil) → c169
EQT(ok, tuplenil(z0)) → c170
EQT(tuplenil(z0), ok) → c171
EQT(a, true) → c172
EQT(true, a) → c173
EQT(locker, tag) → c174
EQT(tag, locker) → c175
EQT(tuple(z0, z1), release) → c176
EQT(lock, pid(z0)) → c177
EQT(true, true) → c178
EQT(pid(z0), lock) → c179
EQT(pending, resource) → c180
EQT(resource, pending) → c181
EQT(lock, false) → c182
EQT(resource, nil) → c183
EQT(excl, locker) → c184
EQT(locker, excl) → c185
EQT(tag, pid(z0)) → c186
EQT(pid(z0), tag) → c187
EQT(a, false) → c188
EQT(pending, ok) → c189
EQT(tuplenil(z0), int(z1)) → c190
EQT(locker, ok) → c191
EQT(tag, tuplenil(z0)) → c192
EQT(pid(z0), tuple(z1, z2)) → c193
EQT(tuple(z0, z1), pid(z2)) → c194
EQT(tuplenil(z0), tag) → c195
EQT(a, mcrlrecord) → c196
EQT(mcrlrecord, a) → c197
EQT(false, tuple(z0, z1)) → c198
EQT(tuple(z0, z1), false) → c199
EQT(excl, pending) → c200
EQT(pending, excl) → c201
EQT(nil, tuplenil(z0)) → c202
EQT(request, cons(z0, z1)) → c203
EQT(tuplenil(z0), nil) → c204
EQT(cons(z0, z1), tuplenil(z2)) → c205
EQT(tuplenil(z0), cons(z1, z2)) → c206
EQT(tag, mcrlrecord) → c207
EQT(ok, int(z0)) → c208
EQT(int(z0), ok) → c209
EQT(tuple(z0, z1), undefined) → c210
EQT(request, release) → c211
EQT(mcrlrecord, mcrlrecord) → c212
EQT(a, pid(z0)) → c213
EQT(tag, release) → c214
EQT(pid(z0), a) → c215
EQT(nil, tuple(z0, z1)) → c216
EQT(tuple(z0, z1), nil) → c217
EQT(request, tag) → c218
EQT(tag, request) → c219
EQT(true, undefined) → c220
EQT(lock, tuplenil(z0)) → c221
EQT(tuplenil(z0), lock) → c222
EQT(pid(z0), mcrlrecord) → c223
EQT(a, tuplenil(z0)) → c224
EQT(tuplenil(z0), a) → c225
EQT(request, tuplenil(z0)) → c226
EQT(tuplenil(z0), request) → c227
EQT(locker, undefined) → c228
EQT(resource, true) → c229
EQT(true, resource) → c230
EQT(ok, cons(z0, z1)) → c231
EQT(true, pid(z0)) → c232
EQT(pid(z0), true) → c233
EQT(excl, pid(z0)) → c234
EQT(mcrlrecord, resource) → c235
EQT(resource, mcrlrecord) → c236
EQT(pid(z0), excl) → c237
EQT(int(z0), false) → c238
EQT(false, cons(z0, z1)) → c239
EQT(tuple(z0, z1), int(z2)) → c240
EQT(int(z0), excl) → c241
EQT(true, false) → c242
EQT(true, mcrlrecord) → c243
EQT(resource, pid(z0)) → c244
EQT(pid(z0), resource) → c245
EQT(excl, resource) → c246
EQT(resource, excl) → c247
EQT(cons(z0, z1), int(z2)) → c248
EQT(true, int(z0)) → c249
EQT(int(z0), true) → c250
EQT(resource, int(z0)) → c251
EQT(int(z0), resource) → c252
EQT(excl, nil) → c253
EQT(tag, undefined) → c254
EQT(ok, undefined) → c255
EQT(resource, false) → c256
EQT(locker, cons(z0, z1)) → c257
EQT(excl, mcrlrecord) → c258
EQT(mcrlrecord, excl) → c259
EQT(request, true) → c260
EQT(true, request) → c261
EQT(nil, cons(z0, z1)) → c262
EQT(resource, tag) → c263
EQT(tag, resource) → c264
EQT(pid(z0), undefined) → c265
EQT(int(z0), release) → c266
EQT(excl, true) → c267
EQT(resource, resource) → c268
EQT(true, excl) → c269
EQT(pending, tuple(z0, z1)) → c270
EQT(tuple(z0, z1), pending) → c271
EQT(pid(z0), tuplenil(z1)) → c272
EQT(tuplenil(z0), pid(z1)) → c273
EQT(tag, int(z0)) → c274
EQT(int(z0), tag) → c275
EQT(cons(z0, z1), cons(z2, z3)) → c276(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(excl, false) → c277
EQT(request, resource) → c278
EQT(resource, request) → c279
EQT(nil, undefined) → c280
EQT(undefined, nil) → c281
EQT(lock, undefined) → c282
EQT(true, tuplenil(z0)) → c283
EQT(tuplenil(z0), true) → c284
EQT(locker, tuple(z0, z1)) → c285
EQT(tuple(z0, z1), locker) → c286
EQT(resource, tuplenil(z0)) → c287
EQT(tuplenil(z0), resource) → c288
EQT(excl, release) → c289
EQT(release, excl) → c290
EQT(a, excl) → c291
EQT(excl, a) → c292
EQT(int(z0), mcrlrecord) → c293
EQT(excl, request) → c294
LOCKER2_MAP_ADD_PENDING(nil, z0, z1) → c295
LOCKER2_OBTAINABLES(nil, z0) → c296
LOCKER2_OBTAINABLES(cons(z0, z1), z2) → c297(CASE5(z2, z1, z0, member(z2, record_extract(z0, lock, pending))), MEMBER(z2, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
RECORD_UPDATES(z0, z1, nil) → c298
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4), RECORD_UPDATE(z0, z1, z2, z3))
GEN_TAG(z0) → c300
ISTOPS(z0, stack(z1, z2)) → c301(EQT(z0, z1))
ISTOPS(z0, empty) → c302
LOCKER2_MAP_PROMOTE_PENDING(nil, z0) → c303
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_PROMOTE_PENDING(z0, z2), LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
CASE9(z0, z1, z2, true) → c306
CASE9(z0, z1, z2, false) → c307(MEMBER(z2, z0))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
ELEMENT(int(s(0)), tuple(z0, z1)) → c309
ELEMENT(int(s(0)), tuplenil(z0)) → c310
PUSH(z0, z1, calls(z2, z3, z4)) → c311(PUSH1(z0, z1, z2, z3, z4, eqt(z0, z2)), EQT(z0, z2))
PUSH(z0, z1, nocalls) → c312
CASE0(z0, z1, z2) → c313
CASE0(z0, z1, cons(z0, z2)) → c314(RECORD_UPDATES(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil))))
EQS(stack(z0, z1), stack(z2, z3)) → c315(AND(eqt(z0, z2), eqs(z1, z3)), EQT(z0, z2), EQS(z1, z3))
EQS(empty, stack(z0, z1)) → c316
EQS(stack(z0, z1), empty) → c317
EQS(empty, empty) → c318
LOCKER2_RELEASE_LOCK(z0, z1) → c319(CASE2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl))), GEN_MODTAGEQ(z1, record_extract(z0, lock, excl)), RECORD_EXTRACT(z0, lock, excl))
LOCKER2_MAP_CLAIM_LOCK(nil, z0, z1) → c320
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
CASE1(z0, z1, z2, false) → c322
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)), APPEND(record_extract(z2, lock, pending), cons(z0, nil)), RECORD_EXTRACT(z2, lock, pending))
RECORD_UPDATE(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → c324
PUSH1(z0, z1, z2, z3, z4, T) → c325(PUSHS(z1, z3))
LOCKER2_PROMOTE_PENDING(z0, z1) → c326(CASE0(z1, z0, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
DELETE(z0, cons(z1, z2)) → c327(CASE8(z2, z1, z0, equal(z0, z1)))
DELETE(z0, nil) → c328
LOCKER2_ADDUNIQ(nil, z0) → c329
CASE6(z0, z1, z2, true) → c330(RECORD_EXTRACT(z1, lock, excl), RECORD_EXTRACT(z1, lock, pending))
CASE6(z0, z1, z2, false) → c331(LOCKER2_CHECK_AVAILABLE(z2, z0))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2), DELETE(z1, z0))
SUBTRACT(z0, nil) → c333
LOCKER2_REMOVE_PENDING(z0, z1) → c334(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)), SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)), RECORD_EXTRACT(z0, lock, pending))
CASE5(z0, z1, z2, true) → c335(LOCKER2_OBTAINABLES(z1, z0))
CASE5(z0, z1, z2, false) → c336(LOCKER2_OBTAINABLES(z1, z0))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLE(z0, z2), LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_CHECK_AVAILABLES(nil, z0) → c338
CASE8(z0, z1, z2, false) → c339(DELETE(z2, z0))
CASE8(z0, z1, z2, true) → c340
EQC(nocalls, nocalls) → c341
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(AND(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5))), EQT(z0, z3), AND(eqs(z1, z4), eqc(z2, z5)), EQS(z1, z4), EQC(z2, z5))
EQC(nocalls, calls(z0, z1, z2)) → c343
EQC(calls(z0, z1, z2), nocalls) → c344
OR(F, F) → c345
OR(F, T) → c346
OR(T, F) → c347
OR(T, T) → c348
IMP(F, z0) → c349
IMP(T, z0) → c350
GEN_MODTAGEQ(z0, z1) → c351
AND(T, z0) → c352
AND(z0, T) → c353
AND(F, z0) → c354
AND(z0, F) → c355
EQ(F, F) → c356
EQ(T, T) → c357
EQ(T, F) → c358
EQ(F, T) → c359
LOCKER2_CHECK_AVAILABLE(z0, nil) → c360
LOCKER2_CHECK_AVAILABLE(z0, cons(z1, z2)) → c361(CASE6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource))), RECORD_EXTRACT(z1, lock, resource))
MEMBER(z0, cons(z1, z2)) → c362(CASE9(z2, z1, z0, equal(z0, z1)))
MEMBER(z0, nil) → c363
RECORD_EXTRACT(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → c364
RECORD_NEW(lock) → c365
PUSHS(z0, z1) → c366
CASE4(z0, z1, z2) → c367
IF(T, z0, z1) → c368
IF(F, z0, z1) → c369
NOT(F) → c370
NOT(T) → c371
TOPS(stack(z0, z1)) → c372
CASE2(z0, z1, true) → c373(RECORD_UPDATES(z1, lock, cons(tuple(excllock, excl), nil)))
POPS(stack(z0, z1)) → c374
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)), MEMBER(record_extract(z0, lock, resource), z1), RECORD_EXTRACT(z0, lock, resource))

S tuples:

EQT(locker, release) → c
EQT(release, locker) → c1
EQT(mcrlrecord, release) → c2
EQT(release, mcrlrecord) → c3
EQT(pending, undefined) → c4
EQT(release, false) → c5
EQT(a, int(z0)) → c6
EQT(int(z0), a) → c7
EQT(tag, tuple(z0, z1)) → c8
EQT(tuple(z0, z1), tag) → c9
EQT(request, undefined) → c10
EQT(a, a) → c11
EQT(false, tuplenil(z0)) → c12
EQT(lock, resource) → c13
EQT(resource, lock) → c14
EQT(tuplenil(z0), false) → c15
EQT(excl, tag) → c16
EQT(lock, ok) → c17
EQT(tag, excl) → c18
EQT(a, resource) → c19
EQT(resource, a) → c20
EQT(pending, pid(z0)) → c21
EQT(pid(z0), pending) → c22
EQT(pending, pending) → c23
EQT(request, request) → c24
EQT(excl, lock) → c25
EQT(lock, excl) → c26
EQT(a, nil) → c27
EQT(pending, true) → c28
EQT(true, pending) → c29
EQT(tuple(z0, z1), excl) → c30
EQT(nil, pid(z0)) → c31
EQT(pid(z0), nil) → c32
EQT(lock, cons(z0, z1)) → c33
EQT(tuplenil(z0), mcrlrecord) → c34
EQT(ok, tuple(z0, z1)) → c35
EQT(tuple(z0, z1), ok) → c36
EQT(lock, int(z0)) → c37
EQT(locker, pending) → c38
EQT(pending, locker) → c39
EQT(true, release) → c40
EQT(int(z0), lock) → c41
EQT(mcrlrecord, request) → c42
EQT(request, mcrlrecord) → c43
EQT(cons(z0, z1), tuple(z2, z3)) → c44
EQT(tuple(z0, z1), cons(z2, z3)) → c45
EQT(excl, ok) → c46
EQT(undefined, tuplenil(z0)) → c47
EQT(tuplenil(z0), undefined) → c48
EQT(int(z0), undefined) → c49
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), release) → c51
EQT(a, request) → c52
EQT(resource, undefined) → c53
EQT(lock, request) → c54
EQT(pid(z0), int(z1)) → c55
EQT(mcrlrecord, nil) → c56
EQT(tag, cons(z0, z1)) → c57
EQT(cons(z0, z1), tag) → c58
EQT(locker, nil) → c59
EQT(a, cons(z0, z1)) → c60
EQT(lock, tuple(z0, z1)) → c61
EQT(pid(z0), release) → c62
EQT(tuple(z0, z1), lock) → c63
EQT(true, nil) → c64
EQT(a, release) → c65
EQT(release, a) → c66
EQT(mcrlrecord, false) → c67
EQT(request, pid(z0)) → c68
EQT(pid(z0), request) → c69
EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(a, tag) → c71
EQT(tag, a) → c72
EQT(pending, release) → c73
EQT(pid(z0), false) → c74
EQT(ok, pid(z0)) → c75
EQT(pid(z0), ok) → c76
EQT(excl, undefined) → c77
EQT(true, cons(z0, z1)) → c78
EQT(cons(z0, z1), true) → c79
EQT(pending, tuplenil(z0)) → c80
EQT(tuplenil(z0), pending) → c81
EQT(pid(z0), cons(z1, z2)) → c82
EQT(cons(z0, z1), pid(z2)) → c83
EQT(locker, resource) → c84
EQT(ok, resource) → c85
EQT(resource, locker) → c86
EQT(resource, ok) → c87
EQT(pending, tag) → c88
EQT(tag, pending) → c89
EQT(a, lock) → c90
EQT(lock, a) → c91
EQT(request, tuple(z0, z1)) → c92
EQT(tuple(z0, z1), request) → c93
EQT(lock, release) → c94
EQT(release, lock) → c95
EQT(tag, tag) → c96
EQT(resource, cons(z0, z1)) → c97
EQT(cons(z0, z1), resource) → c98
EQT(cons(z0, z1), undefined) → c99
EQT(lock, tag) → c100
EQT(tag, lock) → c101
EQT(release, nil) → c102
EQT(locker, pid(z0)) → c103
EQT(pid(z0), locker) → c104
EQT(tag, nil) → c105
EQT(ok, true) → c106
EQT(true, ok) → c107
EQT(lock, pending) → c108
EQT(locker, false) → c109
EQT(pending, lock) → c110
EQT(a, tuple(z0, z1)) → c111
EQT(locker, int(z0)) → c112
EQT(int(z0), locker) → c113
EQT(tuple(z0, z1), a) → c114
EQT(lock, nil) → c115
EQT(lock, lock) → c116
EQT(a, locker) → c117
EQT(a, pending) → c118
EQT(locker, a) → c119
EQT(pending, a) → c120
EQT(true, tuple(z0, z1)) → c121
EQT(tuple(z0, z1), true) → c122
EQT(pending, request) → c123
EQT(request, pending) → c124
EQT(tuple(z0, z1), mcrlrecord) → c125
EQT(a, ok) → c126
EQT(request, ok) → c127
EQT(locker, mcrlrecord) → c128
EQT(mcrlrecord, locker) → c129
EQT(mcrlrecord, ok) → c130
EQT(pending, false) → c131
EQT(locker, request) → c132
EQT(ok, tag) → c133
EQT(tag, ok) → c134
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(resource, tuple(z0, z1)) → c136
EQT(tuple(z0, z1), resource) → c137
EQT(locker, true) → c138
EQT(true, locker) → c139
EQT(mcrlrecord, pending) → c140
EQT(pending, mcrlrecord) → c141
EQT(locker, tuplenil(z0)) → c142
EQT(tuplenil(z0), locker) → c143
EQT(tuplenil(z0), excl) → c144
EQT(a, undefined) → c145
EQT(undefined, a) → c146
EQT(release, ok) → c147
EQT(request, int(z0)) → c148
EQT(int(z0), request) → c149
EQT(locker, locker) → c150
EQT(lock, true) → c151
EQT(true, lock) → c152
EQT(lock, mcrlrecord) → c153
EQT(mcrlrecord, lock) → c154
EQT(pending, cons(z0, z1)) → c155
EQT(pending, int(z0)) → c156
EQT(int(z0), pending) → c157
EQT(tag, false) → c158
EQT(tuple(z0, z1), tuplenil(z2)) → c159
EQT(tuplenil(z0), tuple(z1, z2)) → c160
EQT(pending, nil) → c161
EQT(tag, true) → c162
EQT(true, tag) → c163
EQT(lock, locker) → c164
EQT(locker, lock) → c165
EQT(resource, release) → c166
EQT(excl, excl) → c167
EQT(nil, int(z0)) → c168
EQT(int(z0), nil) → c169
EQT(ok, tuplenil(z0)) → c170
EQT(tuplenil(z0), ok) → c171
EQT(a, true) → c172
EQT(true, a) → c173
EQT(locker, tag) → c174
EQT(tag, locker) → c175
EQT(tuple(z0, z1), release) → c176
EQT(lock, pid(z0)) → c177
EQT(true, true) → c178
EQT(pid(z0), lock) → c179
EQT(pending, resource) → c180
EQT(resource, pending) → c181
EQT(lock, false) → c182
EQT(resource, nil) → c183
EQT(excl, locker) → c184
EQT(locker, excl) → c185
EQT(tag, pid(z0)) → c186
EQT(pid(z0), tag) → c187
EQT(a, false) → c188
EQT(pending, ok) → c189
EQT(tuplenil(z0), int(z1)) → c190
EQT(locker, ok) → c191
EQT(tag, tuplenil(z0)) → c192
EQT(pid(z0), tuple(z1, z2)) → c193
EQT(tuple(z0, z1), pid(z2)) → c194
EQT(tuplenil(z0), tag) → c195
EQT(a, mcrlrecord) → c196
EQT(mcrlrecord, a) → c197
EQT(false, tuple(z0, z1)) → c198
EQT(tuple(z0, z1), false) → c199
EQT(excl, pending) → c200
EQT(pending, excl) → c201
EQT(nil, tuplenil(z0)) → c202
EQT(request, cons(z0, z1)) → c203
EQT(tuplenil(z0), nil) → c204
EQT(cons(z0, z1), tuplenil(z2)) → c205
EQT(tuplenil(z0), cons(z1, z2)) → c206
EQT(tag, mcrlrecord) → c207
EQT(ok, int(z0)) → c208
EQT(int(z0), ok) → c209
EQT(tuple(z0, z1), undefined) → c210
EQT(request, release) → c211
EQT(mcrlrecord, mcrlrecord) → c212
EQT(a, pid(z0)) → c213
EQT(tag, release) → c214
EQT(pid(z0), a) → c215
EQT(nil, tuple(z0, z1)) → c216
EQT(tuple(z0, z1), nil) → c217
EQT(request, tag) → c218
EQT(tag, request) → c219
EQT(true, undefined) → c220
EQT(lock, tuplenil(z0)) → c221
EQT(tuplenil(z0), lock) → c222
EQT(pid(z0), mcrlrecord) → c223
EQT(a, tuplenil(z0)) → c224
EQT(tuplenil(z0), a) → c225
EQT(request, tuplenil(z0)) → c226
EQT(tuplenil(z0), request) → c227
EQT(locker, undefined) → c228
EQT(resource, true) → c229
EQT(true, resource) → c230
EQT(ok, cons(z0, z1)) → c231
EQT(true, pid(z0)) → c232
EQT(pid(z0), true) → c233
EQT(excl, pid(z0)) → c234
EQT(mcrlrecord, resource) → c235
EQT(resource, mcrlrecord) → c236
EQT(pid(z0), excl) → c237
EQT(int(z0), false) → c238
EQT(false, cons(z0, z1)) → c239
EQT(tuple(z0, z1), int(z2)) → c240
EQT(int(z0), excl) → c241
EQT(true, false) → c242
EQT(true, mcrlrecord) → c243
EQT(resource, pid(z0)) → c244
EQT(pid(z0), resource) → c245
EQT(excl, resource) → c246
EQT(resource, excl) → c247
EQT(cons(z0, z1), int(z2)) → c248
EQT(true, int(z0)) → c249
EQT(int(z0), true) → c250
EQT(resource, int(z0)) → c251
EQT(int(z0), resource) → c252
EQT(excl, nil) → c253
EQT(tag, undefined) → c254
EQT(ok, undefined) → c255
EQT(resource, false) → c256
EQT(locker, cons(z0, z1)) → c257
EQT(excl, mcrlrecord) → c258
EQT(mcrlrecord, excl) → c259
EQT(request, true) → c260
EQT(true, request) → c261
EQT(nil, cons(z0, z1)) → c262
EQT(resource, tag) → c263
EQT(tag, resource) → c264
EQT(pid(z0), undefined) → c265
EQT(int(z0), release) → c266
EQT(excl, true) → c267
EQT(resource, resource) → c268
EQT(true, excl) → c269
EQT(pending, tuple(z0, z1)) → c270
EQT(tuple(z0, z1), pending) → c271
EQT(pid(z0), tuplenil(z1)) → c272
EQT(tuplenil(z0), pid(z1)) → c273
EQT(tag, int(z0)) → c274
EQT(int(z0), tag) → c275
EQT(cons(z0, z1), cons(z2, z3)) → c276(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(excl, false) → c277
EQT(request, resource) → c278
EQT(resource, request) → c279
EQT(nil, undefined) → c280
EQT(undefined, nil) → c281
EQT(lock, undefined) → c282
EQT(true, tuplenil(z0)) → c283
EQT(tuplenil(z0), true) → c284
EQT(locker, tuple(z0, z1)) → c285
EQT(tuple(z0, z1), locker) → c286
EQT(resource, tuplenil(z0)) → c287
EQT(tuplenil(z0), resource) → c288
EQT(excl, release) → c289
EQT(release, excl) → c290
EQT(a, excl) → c291
EQT(excl, a) → c292
EQT(int(z0), mcrlrecord) → c293
EQT(excl, request) → c294
LOCKER2_MAP_ADD_PENDING(nil, z0, z1) → c295
LOCKER2_OBTAINABLES(nil, z0) → c296
LOCKER2_OBTAINABLES(cons(z0, z1), z2) → c297(CASE5(z2, z1, z0, member(z2, record_extract(z0, lock, pending))), MEMBER(z2, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
RECORD_UPDATES(z0, z1, nil) → c298
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4), RECORD_UPDATE(z0, z1, z2, z3))
GEN_TAG(z0) → c300
ISTOPS(z0, stack(z1, z2)) → c301(EQT(z0, z1))
ISTOPS(z0, empty) → c302
LOCKER2_MAP_PROMOTE_PENDING(nil, z0) → c303
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_PROMOTE_PENDING(z0, z2), LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
CASE9(z0, z1, z2, true) → c306
CASE9(z0, z1, z2, false) → c307(MEMBER(z2, z0))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
ELEMENT(int(s(0)), tuple(z0, z1)) → c309
ELEMENT(int(s(0)), tuplenil(z0)) → c310
PUSH(z0, z1, calls(z2, z3, z4)) → c311(PUSH1(z0, z1, z2, z3, z4, eqt(z0, z2)), EQT(z0, z2))
PUSH(z0, z1, nocalls) → c312
CASE0(z0, z1, z2) → c313
CASE0(z0, z1, cons(z0, z2)) → c314(RECORD_UPDATES(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil))))
EQS(stack(z0, z1), stack(z2, z3)) → c315(AND(eqt(z0, z2), eqs(z1, z3)), EQT(z0, z2), EQS(z1, z3))
EQS(empty, stack(z0, z1)) → c316
EQS(stack(z0, z1), empty) → c317
EQS(empty, empty) → c318
LOCKER2_RELEASE_LOCK(z0, z1) → c319(CASE2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl))), GEN_MODTAGEQ(z1, record_extract(z0, lock, excl)), RECORD_EXTRACT(z0, lock, excl))
LOCKER2_MAP_CLAIM_LOCK(nil, z0, z1) → c320
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
CASE1(z0, z1, z2, false) → c322
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)), APPEND(record_extract(z2, lock, pending), cons(z0, nil)), RECORD_EXTRACT(z2, lock, pending))
RECORD_UPDATE(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → c324
PUSH1(z0, z1, z2, z3, z4, T) → c325(PUSHS(z1, z3))
LOCKER2_PROMOTE_PENDING(z0, z1) → c326(CASE0(z1, z0, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
DELETE(z0, cons(z1, z2)) → c327(CASE8(z2, z1, z0, equal(z0, z1)))
DELETE(z0, nil) → c328
LOCKER2_ADDUNIQ(nil, z0) → c329
CASE6(z0, z1, z2, true) → c330(RECORD_EXTRACT(z1, lock, excl), RECORD_EXTRACT(z1, lock, pending))
CASE6(z0, z1, z2, false) → c331(LOCKER2_CHECK_AVAILABLE(z2, z0))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2), DELETE(z1, z0))
SUBTRACT(z0, nil) → c333
LOCKER2_REMOVE_PENDING(z0, z1) → c334(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)), SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)), RECORD_EXTRACT(z0, lock, pending))
CASE5(z0, z1, z2, true) → c335(LOCKER2_OBTAINABLES(z1, z0))
CASE5(z0, z1, z2, false) → c336(LOCKER2_OBTAINABLES(z1, z0))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLE(z0, z2), LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_CHECK_AVAILABLES(nil, z0) → c338
CASE8(z0, z1, z2, false) → c339(DELETE(z2, z0))
CASE8(z0, z1, z2, true) → c340
EQC(nocalls, nocalls) → c341
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(AND(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5))), EQT(z0, z3), AND(eqs(z1, z4), eqc(z2, z5)), EQS(z1, z4), EQC(z2, z5))
EQC(nocalls, calls(z0, z1, z2)) → c343
EQC(calls(z0, z1, z2), nocalls) → c344
OR(F, F) → c345
OR(F, T) → c346
OR(T, F) → c347
OR(T, T) → c348
IMP(F, z0) → c349
IMP(T, z0) → c350
GEN_MODTAGEQ(z0, z1) → c351
AND(T, z0) → c352
AND(z0, T) → c353
AND(F, z0) → c354
AND(z0, F) → c355
EQ(F, F) → c356
EQ(T, T) → c357
EQ(T, F) → c358
EQ(F, T) → c359
LOCKER2_CHECK_AVAILABLE(z0, nil) → c360
LOCKER2_CHECK_AVAILABLE(z0, cons(z1, z2)) → c361(CASE6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource))), RECORD_EXTRACT(z1, lock, resource))
MEMBER(z0, cons(z1, z2)) → c362(CASE9(z2, z1, z0, equal(z0, z1)))
MEMBER(z0, nil) → c363
RECORD_EXTRACT(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → c364
RECORD_NEW(lock) → c365
PUSHS(z0, z1) → c366
CASE4(z0, z1, z2) → c367
IF(T, z0, z1) → c368
IF(F, z0, z1) → c369
NOT(F) → c370
NOT(T) → c371
TOPS(stack(z0, z1)) → c372
CASE2(z0, z1, true) → c373(RECORD_UPDATES(z1, lock, cons(tuple(excllock, excl), nil)))
POPS(stack(z0, z1)) → c374
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)), MEMBER(record_extract(z0, lock, resource), z1), RECORD_EXTRACT(z0, lock, resource))

K tuples:none
Defined Rule Symbols:

eqt, locker2_map_add_pending, locker2_obtainables, record_updates, gen_tag, istops, locker2_map_promote_pending, append, case9, element, push, case0, eqs, locker2_release_lock, locker2_map_claim_lock, case1, record_update, push1, locker2_promote_pending, delete, locker2_adduniq, case6, subtract, locker2_remove_pending, case5, locker2_check_availables, case8, eqc, or, imp, gen_modtageq, and, eq, locker2_check_available, member, record_extract, record_new, pushs, case4, if, not, tops, case2, pops, locker2_add_pending

Defined Pair Symbols:

EQT, LOCKER2_MAP_ADD_PENDING, LOCKER2_OBTAINABLES, RECORD_UPDATES, GEN_TAG, ISTOPS, LOCKER2_MAP_PROMOTE_PENDING, APPEND, CASE9, ELEMENT, PUSH, CASE0, EQS, LOCKER2_RELEASE_LOCK, LOCKER2_MAP_CLAIM_LOCK, CASE1, RECORD_UPDATE, PUSH1, LOCKER2_PROMOTE_PENDING, DELETE, LOCKER2_ADDUNIQ, CASE6, SUBTRACT, LOCKER2_REMOVE_PENDING, CASE5, LOCKER2_CHECK_AVAILABLES, CASE8, EQC, OR, IMP, GEN_MODTAGEQ, AND, EQ, LOCKER2_CHECK_AVAILABLE, MEMBER, RECORD_EXTRACT, RECORD_NEW, PUSHS, CASE4, IF, NOT, TOPS, CASE2, POPS, LOCKER2_ADD_PENDING

Compound Symbols:

c, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, c59, c60, c61, c62, c63, c64, c65, c66, c67, c68, c69, c70, c71, c72, c73, c74, c75, c76, c77, c78, c79, c80, c81, c82, c83, c84, c85, c86, c87, c88, c89, c90, c91, c92, c93, c94, c95, c96, c97, c98, c99, c100, c101, c102, c103, c104, c105, c106, c107, c108, c109, c110, c111, c112, c113, c114, c115, c116, c117, c118, c119, c120, c121, c122, c123, c124, c125, c126, c127, c128, c129, c130, c131, c132, c133, c134, c135, c136, c137, c138, c139, c140, c141, c142, c143, c144, c145, c146, c147, c148, c149, c150, c151, c152, c153, c154, c155, c156, c157, c158, c159, c160, c161, c162, c163, c164, c165, c166, c167, c168, c169, c170, c171, c172, c173, c174, c175, c176, c177, c178, c179, c180, c181, c182, c183, c184, c185, c186, c187, c188, c189, c190, c191, c192, c193, c194, c195, c196, c197, c198, c199, c200, c201, c202, c203, c204, c205, c206, c207, c208, c209, c210, c211, c212, c213, c214, c215, c216, c217, c218, c219, c220, c221, c222, c223, c224, c225, c226, c227, c228, c229, c230, c231, c232, c233, c234, c235, c236, c237, c238, c239, c240, c241, c242, c243, c244, c245, c246, c247, c248, c249, c250, c251, c252, c253, c254, c255, c256, c257, c258, c259, c260, c261, c262, c263, c264, c265, c266, c267, c268, c269, c270, c271, c272, c273, c274, c275, c276, c277, c278, c279, c280, c281, c282, c283, c284, c285, c286, c287, c288, c289, c290, c291, c292, c293, c294, c295, c296, c297, c298, c299, c300, c301, c302, c303, c304, c305, c306, c307, c308, c309, c310, c311, c312, c313, c314, c315, c316, c317, c318, c319, c320, c321, c322, c323, c324, c325, c326, c327, c328, c329, c330, c331, c332, c333, c334, c335, c336, c337, c338, c339, c340, c341, c342, c343, c344, c345, c346, c347, c348, c349, c350, c351, c352, c353, c354, c355, c356, c357, c358, c359, c360, c361, c362, c363, c364, c365, c366, c367, c368, c369, c370, c371, c372, c373, c374, c375

(5) CdtLeafRemovalProof (ComplexityIfPolyImplication transformation)

Removed 2 leading nodes:

ISTOPS(z0, stack(z1, z2)) → c301(EQT(z0, z1))
CASE0(z0, z1, cons(z0, z2)) → c314(RECORD_UPDATES(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil))))

Removed 357 trailing nodes:

NOT(F) → c370
EQT(mcrlrecord, excl) → c259
EQT(request, mcrlrecord) → c43
EQ(T, T) → c357
EQT(request, pid(z0)) → c68
EQS(empty, stack(z0, z1)) → c316
EQT(a, locker) → c117
EQT(resource, cons(z0, z1)) → c97
EQT(cons(z0, z1), tuple(z2, z3)) → c44
EQC(nocalls, nocalls) → c341
EQT(true, lock) → c152
EQT(request, int(z0)) → c148
EQT(locker, tuplenil(z0)) → c142
CASE9(z0, z1, z2, false) → c307(MEMBER(z2, z0))
EQT(lock, resource) → c13
EQT(a, release) → c65
EQT(a, undefined) → c145
EQT(request, tuple(z0, z1)) → c92
EQT(locker, int(z0)) → c112
EQT(request, tag) → c218
EQT(request, resource) → c278
EQT(excl, pending) → c200
EQT(tuple(z0, z1), false) → c199
EQT(tag, nil) → c105
LOCKER2_ADDUNIQ(nil, z0) → c329
EQT(tuplenil(z0), tuple(z1, z2)) → c160
CASE4(z0, z1, z2) → c367
NOT(T) → c371
EQT(excl, locker) → c184
EQT(pid(z0), cons(z1, z2)) → c82
CASE1(z0, z1, z2, false) → c322
EQT(tuple(z0, z1), true) → c122
EQT(excl, a) → c292
EQT(pending, excl) → c201
EQT(tuplenil(z0), int(z1)) → c190
EQT(int(z0), tag) → c275
EQT(true, resource) → c230
EQT(a, true) → c172
EQT(locker, lock) → c165
LOCKER2_CHECK_AVAILABLE(z0, nil) → c360
EQS(stack(z0, z1), empty) → c317
EQT(locker, a) → c119
RECORD_NEW(lock) → c365
EQT(request, pending) → c124
EQT(tuplenil(z0), resource) → c288
EQT(cons(z0, z1), pid(z2)) → c83
CASE6(z0, z1, z2, true) → c330(RECORD_EXTRACT(z1, lock, excl), RECORD_EXTRACT(z1, lock, pending))
OR(T, F) → c347
EQT(a, tuplenil(z0)) → c224
EQT(mcrlrecord, mcrlrecord) → c212
EQT(tag, false) → c158
EQT(true, undefined) → c220
EQT(tag, resource) → c264
EQT(lock, pending) → c108
EQT(pid(z0), request) → c69
EQT(false, tuplenil(z0)) → c12
EQT(locker, pid(z0)) → c103
EQT(tuple(z0, z1), int(z2)) → c240
EQT(tuple(z0, z1), tag) → c9
EQT(a, mcrlrecord) → c196
EQT(tuplenil(z0), locker) → c143
EQT(release, excl) → c290
EQT(pending, locker) → c39
EQT(tuple(z0, z1), undefined) → c210
EQT(a, pending) → c118
EQT(ok, true) → c106
EQT(ok, tuple(z0, z1)) → c35
EQT(lock, a) → c91
EQT(pending, tuplenil(z0)) → c80
EQT(pid(z0), int(z1)) → c55
EQT(mcrlrecord, false) → c67
EQT(pending, undefined) → c4
EQT(true, mcrlrecord) → c243
EQT(locker, cons(z0, z1)) → c257
EQT(ok, resource) → c85
EQT(tuple(z0, z1), ok) → c36
EQT(mcrlrecord, release) → c2
EQT(locker, ok) → c191
EQT(a, lock) → c90
EQT(resource, ok) → c87
EQT(ok, undefined) → c255
EQT(locker, undefined) → c228
EQT(locker, request) → c132
EQT(true, cons(z0, z1)) → c78
EQT(excl, false) → c277
EQT(cons(z0, z1), int(z2)) → c248
LOCKER2_MAP_PROMOTE_PENDING(nil, z0) → c303
EQT(tag, tag) → c96
EQT(true, nil) → c64
CASE5(z0, z1, z2, false) → c336(LOCKER2_OBTAINABLES(z1, z0))
EQT(lock, locker) → c164
EQT(lock, nil) → c115
EQT(request, request) → c24
EQT(tuple(z0, z1), locker) → c286
EQT(true, request) → c261
EQT(nil, cons(z0, z1)) → c262
CASE9(z0, z1, z2, true) → c306
EQT(pending, ok) → c189
LOCKER2_OBTAINABLES(cons(z0, z1), z2) → c297(CASE5(z2, z1, z0, member(z2, record_extract(z0, lock, pending))), MEMBER(z2, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
IF(F, z0, z1) → c369
RECORD_UPDATES(z0, z1, nil) → c298
EQT(release, locker) → c1
EQT(int(z0), false) → c238
EQT(true, false) → c242
RECORD_EXTRACT(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → c364
EQT(nil, pid(z0)) → c31
CASE5(z0, z1, z2, true) → c335(LOCKER2_OBTAINABLES(z1, z0))
EQT(int(z0), mcrlrecord) → c293
EQT(true, pid(z0)) → c232
EQT(a, pid(z0)) → c213
EQT(mcrlrecord, ok) → c130
EQ(F, F) → c356
EQT(mcrlrecord, pending) → c140
EQT(tuplenil(z0), lock) → c222
EQT(excl, request) → c294
ISTOPS(z0, empty) → c302
EQT(tuplenil(z0), request) → c227
SUBTRACT(z0, nil) → c333
EQT(tag, lock) → c101
EQT(tag, request) → c219
EQT(cons(z0, z1), tag) → c58
EQT(a, resource) → c19
EQT(true, tuplenil(z0)) → c283
EQT(excl, resource) → c246
EQT(lock, release) → c94
EQT(cons(z0, z1), undefined) → c99
EQT(tuplenil(z0), nil) → c204
EQT(true, tag) → c163
EQT(tag, pending) → c89
EQT(locker, resource) → c84
EQT(resource, a) → c20
EQT(true, int(z0)) → c249
EQ(T, F) → c358
CASE2(z0, z1, true) → c373(RECORD_UPDATES(z1, lock, cons(tuple(excllock, excl), nil)))
AND(z0, T) → c353
CASE8(z0, z1, z2, true) → c340
EQT(tuplenil(z0), true) → c284
EQT(excl, tag) → c16
EQT(int(z0), pending) → c157
EQT(pid(z0), pending) → c22
EQT(request, tuplenil(z0)) → c226
EQT(mcrlrecord, nil) → c56
LOCKER2_MAP_CLAIM_LOCK(nil, z0, z1) → c320
EQT(tuple(z0, z1), tuplenil(z2)) → c159
EQT(resource, nil) → c183
EQT(tuplenil(z0), undefined) → c48
EQT(ok, tag) → c133
EQT(pid(z0), lock) → c179
EQT(tag, int(z0)) → c274
EQT(excl, release) → c289
EQT(tuplenil(z0), excl) → c144
EQT(pid(z0), release) → c62
EQT(tuple(z0, z1), a) → c114
EQT(tuplenil(z0), pid(z1)) → c273
EQT(resource, int(z0)) → c251
EQT(pending, request) → c123
EQT(tuplenil(z0), ok) → c171
EQT(int(z0), true) → c250
EQT(int(z0), a) → c7
GEN_MODTAGEQ(z0, z1) → c351
EQT(int(z0), nil) → c169
EQT(int(z0), resource) → c252
EQT(tag, true) → c162
EQT(lock, tag) → c100
EQT(tuple(z0, z1), release) → c176
EQT(cons(z0, z1), true) → c79
LOCKER2_CHECK_AVAILABLES(nil, z0) → c338
EQT(tuple(z0, z1), pid(z2)) → c194
EQT(int(z0), ok) → c209
EQT(pending, int(z0)) → c156
EQT(undefined, nil) → c281
EQT(tuple(z0, z1), nil) → c217
LOCKER2_OBTAINABLES(nil, z0) → c296
EQT(ok, int(z0)) → c208
EQT(tag, mcrlrecord) → c207
EQT(pid(z0), undefined) → c265
EQT(tag, release) → c214
EQC(nocalls, calls(z0, z1, z2)) → c343
EQT(locker, tag) → c174
EQT(locker, mcrlrecord) → c128
PUSHS(z0, z1) → c366
EQT(tuplenil(z0), tag) → c195
EQT(lock, false) → c182
AND(z0, F) → c355
EQT(pending, nil) → c161
EQT(request, cons(z0, z1)) → c203
EQT(excl, lock) → c25
EQT(resource, release) → c166
OR(T, T) → c348
EQT(ok, tuplenil(z0)) → c170
EQT(resource, false) → c256
EQT(mcrlrecord, resource) → c235
EQT(locker, excl) → c185
EQT(lock, tuple(z0, z1)) → c61
EQT(tag, cons(z0, z1)) → c57
EQT(cons(z0, z1), resource) → c98
EQT(excl, undefined) → c77
EQT(pid(z0), tuple(z1, z2)) → c193
EQT(mcrlrecord, a) → c197
EQT(resource, locker) → c86
EQT(a, cons(z0, z1)) → c60
CASE8(z0, z1, z2, false) → c339(DELETE(z2, z0))
EQT(tuplenil(z0), cons(z1, z2)) → c206
EQT(request, true) → c260
EQT(lock, mcrlrecord) → c153
OR(F, T) → c346
EQT(true, ok) → c107
EQT(lock, pid(z0)) → c177
ELEMENT(int(s(0)), tuple(z0, z1)) → c309
LOCKER2_MAP_ADD_PENDING(nil, z0, z1) → c295
EQT(resource, request) → c279
EQT(tuplenil(z0), a) → c225
EQT(resource, tag) → c263
EQT(resource, true) → c229
EQT(tuple(z0, z1), cons(z2, z3)) → c45
EQT(resource, lock) → c14
LOCKER2_RELEASE_LOCK(z0, z1) → c319(CASE2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl))), GEN_MODTAGEQ(z1, record_extract(z0, lock, excl)), RECORD_EXTRACT(z0, lock, excl))
EQT(pending, cons(z0, z1)) → c155
ELEMENT(int(s(0)), tuplenil(z0)) → c310
EQT(a, false) → c188
EQT(true, true) → c178
EQT(release, lock) → c95
EQT(tuple(z0, z1), resource) → c137
EQT(tuple(z0, z1), excl) → c30
EQT(tag, tuple(z0, z1)) → c8
EQT(tag, tuplenil(z0)) → c192
EQT(tag, undefined) → c254
EQT(a, ok) → c126
EQT(tuplenil(z0), false) → c15
EQT(request, undefined) → c10
EQT(tag, pid(z0)) → c186
EQT(a, a) → c11
DELETE(z0, cons(z1, z2)) → c327(CASE8(z2, z1, z0, equal(z0, z1)))
OR(F, F) → c345
EQT(pid(z0), a) → c215
DELETE(z0, nil) → c328
EQT(mcrlrecord, lock) → c154
EQT(locker, locker) → c150
EQT(resource, pending) → c181
EQT(pending, lock) → c110
EQT(pid(z0), locker) → c104
EQT(request, ok) → c127
POPS(stack(z0, z1)) → c374
GEN_TAG(z0) → c300
EQT(resource, excl) → c247
EQT(true, locker) → c139
EQT(a, request) → c52
EQT(request, release) → c211
EQT(int(z0), request) → c149
EQT(a, int(z0)) → c6
TOPS(stack(z0, z1)) → c372
EQT(pid(z0), mcrlrecord) → c223
PUSH1(z0, z1, z2, z3, z4, T) → c325(PUSHS(z1, z3))
EQT(release, ok) → c147
MEMBER(z0, cons(z1, z2)) → c362(CASE9(z2, z1, z0, equal(z0, z1)))
EQT(false, tuple(z0, z1)) → c198
EQT(a, tag) → c71
LOCKER2_PROMOTE_PENDING(z0, z1) → c326(CASE0(z1, z0, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
EQT(resource, resource) → c268
EQT(pending, release) → c73
EQT(tag, excl) → c18
CASE6(z0, z1, z2, false) → c331(LOCKER2_CHECK_AVAILABLE(z2, z0))
EQT(pending, false) → c131
EQT(pending, tag) → c88
EQT(pid(z0), true) → c233
EQT(true, pending) → c29
EQT(resource, mcrlrecord) → c236
EQT(tuplenil(z0), pending) → c81
EQT(undefined, tuplenil(z0)) → c47
EQT(a, excl) → c291
EQS(empty, empty) → c318
EQT(release, mcrlrecord) → c3
EQT(pending, pid(z0)) → c21
PUSH(z0, z1, nocalls) → c312
EQT(nil, tuplenil(z0)) → c202
EQT(pid(z0), false) → c74
EQT(lock, int(z0)) → c37
EQT(undefined, a) → c146
EQT(true, tuple(z0, z1)) → c121
EQT(release, false) → c5
EQT(locker, release) → c
EQT(false, cons(z0, z1)) → c239
EQT(int(z0), release) → c266
EQT(ok, cons(z0, z1)) → c231
EQT(pending, tuple(z0, z1)) → c270
EQT(pending, true) → c28
EQT(release, a) → c66
EQT(pid(z0), resource) → c245
EQT(true, a) → c173
EQT(tuplenil(z0), mcrlrecord) → c34
EQT(pid(z0), tag) → c187
RECORD_UPDATE(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → c324
EQT(pid(z0), tuplenil(z1)) → c272
EQT(true, excl) → c269
EQT(excl, true) → c267
EQT(locker, false) → c109
EQT(pending, resource) → c180
EQT(lock, lock) → c116
EQT(tuple(z0, z1), lock) → c63
EQT(int(z0), locker) → c113
EQT(mcrlrecord, locker) → c129
EQT(int(z0), excl) → c241
EQT(nil, undefined) → c280
EQT(excl, ok) → c46
EQT(mcrlrecord, request) → c42
IMP(F, z0) → c349
EQC(calls(z0, z1, z2), nocalls) → c344
EQT(lock, request) → c54
EQT(tuplenil(z0), release) → c51
EQT(int(z0), undefined) → c49
LOCKER2_CHECK_AVAILABLE(z0, cons(z1, z2)) → c361(CASE6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource))), RECORD_EXTRACT(z1, lock, resource))
EQT(tuple(z0, z1), request) → c93
EQT(ok, pid(z0)) → c75
EQT(tag, locker) → c175
EQT(resource, undefined) → c53
EQT(pending, a) → c120
EQT(pid(z0), ok) → c76
EQT(lock, tuplenil(z0)) → c221
EQT(int(z0), lock) → c41
EQT(lock, excl) → c26
CASE0(z0, z1, z2) → c313
IF(T, z0, z1) → c368
EQT(lock, true) → c151
EQT(tag, ok) → c134
EQT(lock, cons(z0, z1)) → c33
EQT(a, nil) → c27
EQT(nil, tuple(z0, z1)) → c216
EQT(locker, pending) → c38
EQT(excl, nil) → c253
EQT(a, tuple(z0, z1)) → c111
EQT(pid(z0), excl) → c237
EQT(excl, mcrlrecord) → c258
EQT(tag, a) → c72
EQT(locker, true) → c138
EQT(true, release) → c40
IMP(T, z0) → c350
MEMBER(z0, nil) → c363
EQ(F, T) → c359
EQT(cons(z0, z1), tuplenil(z2)) → c205
EQT(tuple(z0, z1), pending) → c271
EQT(resource, tuplenil(z0)) → c287
EQT(locker, tuple(z0, z1)) → c285
EQT(release, nil) → c102
EQT(lock, ok) → c17
EQT(excl, pid(z0)) → c234
EQT(nil, int(z0)) → c168
EQT(pending, mcrlrecord) → c141
EQT(pending, pending) → c23
AND(F, z0) → c354
EQT(resource, pid(z0)) → c244
EQT(resource, tuple(z0, z1)) → c136
EQT(locker, nil) → c59
EQT(pid(z0), nil) → c32
EQT(tuple(z0, z1), mcrlrecord) → c125
EQT(lock, undefined) → c282
AND(T, z0) → c352
EQT(excl, excl) → c167

(6) Obligation:

Complexity Dependency Tuples Problem
Rules:

eqt(locker, release) → F
eqt(release, locker) → F
eqt(mcrlrecord, release) → F
eqt(release, mcrlrecord) → F
eqt(pending, undefined) → F
eqt(release, false) → F
eqt(a, int(z0)) → F
eqt(int(z0), a) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tuple(z0, z1), tag) → F
eqt(request, undefined) → F
eqt(a, a) → T
eqt(false, tuplenil(z0)) → F
eqt(lock, resource) → F
eqt(resource, lock) → F
eqt(tuplenil(z0), false) → F
eqt(excl, tag) → F
eqt(lock, ok) → F
eqt(tag, excl) → F
eqt(a, resource) → F
eqt(resource, a) → F
eqt(pending, pid(z0)) → F
eqt(pid(z0), pending) → F
eqt(pending, pending) → T
eqt(request, request) → T
eqt(excl, lock) → F
eqt(lock, excl) → F
eqt(a, nil) → F
eqt(pending, true) → F
eqt(true, pending) → F
eqt(tuple(z0, z1), excl) → F
eqt(nil, pid(z0)) → F
eqt(pid(z0), nil) → F
eqt(lock, cons(z0, z1)) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(ok, tuple(z0, z1)) → F
eqt(tuple(z0, z1), ok) → F
eqt(lock, int(z0)) → F
eqt(locker, pending) → F
eqt(pending, locker) → F
eqt(true, release) → F
eqt(int(z0), lock) → F
eqt(mcrlrecord, request) → F
eqt(request, mcrlrecord) → F
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(excl, ok) → F
eqt(undefined, tuplenil(z0)) → F
eqt(tuplenil(z0), undefined) → F
eqt(int(z0), undefined) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuplenil(z0), release) → F
eqt(a, request) → F
eqt(resource, undefined) → F
eqt(lock, request) → F
eqt(pid(z0), int(z1)) → F
eqt(mcrlrecord, nil) → F
eqt(tag, cons(z0, z1)) → F
eqt(cons(z0, z1), tag) → F
eqt(locker, nil) → F
eqt(a, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(pid(z0), release) → F
eqt(tuple(z0, z1), lock) → F
eqt(true, nil) → F
eqt(a, release) → F
eqt(release, a) → F
eqt(mcrlrecord, false) → F
eqt(request, pid(z0)) → F
eqt(pid(z0), request) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
eqt(a, tag) → F
eqt(tag, a) → F
eqt(pending, release) → F
eqt(pid(z0), false) → F
eqt(ok, pid(z0)) → F
eqt(pid(z0), ok) → F
eqt(excl, undefined) → F
eqt(true, cons(z0, z1)) → F
eqt(cons(z0, z1), true) → F
eqt(pending, tuplenil(z0)) → F
eqt(tuplenil(z0), pending) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(locker, resource) → F
eqt(ok, resource) → F
eqt(resource, locker) → F
eqt(resource, ok) → F
eqt(pending, tag) → F
eqt(tag, pending) → F
eqt(a, lock) → F
eqt(lock, a) → F
eqt(request, tuple(z0, z1)) → F
eqt(tuple(z0, z1), request) → F
eqt(lock, release) → F
eqt(release, lock) → F
eqt(tag, tag) → T
eqt(resource, cons(z0, z1)) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), undefined) → F
eqt(lock, tag) → F
eqt(tag, lock) → F
eqt(release, nil) → F
eqt(locker, pid(z0)) → F
eqt(pid(z0), locker) → F
eqt(tag, nil) → F
eqt(ok, true) → F
eqt(true, ok) → F
eqt(lock, pending) → F
eqt(locker, false) → F
eqt(pending, lock) → F
eqt(a, tuple(z0, z1)) → F
eqt(locker, int(z0)) → F
eqt(int(z0), locker) → F
eqt(tuple(z0, z1), a) → F
eqt(lock, nil) → F
eqt(lock, lock) → T
eqt(a, locker) → F
eqt(a, pending) → F
eqt(locker, a) → F
eqt(pending, a) → F
eqt(true, tuple(z0, z1)) → F
eqt(tuple(z0, z1), true) → F
eqt(pending, request) → F
eqt(request, pending) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(a, ok) → F
eqt(request, ok) → F
eqt(locker, mcrlrecord) → F
eqt(mcrlrecord, locker) → F
eqt(mcrlrecord, ok) → F
eqt(pending, false) → F
eqt(locker, request) → F
eqt(ok, tag) → F
eqt(tag, ok) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(resource, tuple(z0, z1)) → F
eqt(tuple(z0, z1), resource) → F
eqt(locker, true) → F
eqt(true, locker) → F
eqt(mcrlrecord, pending) → F
eqt(pending, mcrlrecord) → F
eqt(locker, tuplenil(z0)) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), excl) → F
eqt(a, undefined) → F
eqt(undefined, a) → F
eqt(release, ok) → F
eqt(request, int(z0)) → F
eqt(int(z0), request) → F
eqt(locker, locker) → T
eqt(lock, true) → F
eqt(true, lock) → F
eqt(lock, mcrlrecord) → F
eqt(mcrlrecord, lock) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, int(z0)) → F
eqt(int(z0), pending) → F
eqt(tag, false) → F
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(pending, nil) → F
eqt(tag, true) → F
eqt(true, tag) → F
eqt(lock, locker) → F
eqt(locker, lock) → F
eqt(resource, release) → F
eqt(excl, excl) → T
eqt(nil, int(z0)) → F
eqt(int(z0), nil) → F
eqt(ok, tuplenil(z0)) → F
eqt(tuplenil(z0), ok) → F
eqt(a, true) → F
eqt(true, a) → F
eqt(locker, tag) → F
eqt(tag, locker) → F
eqt(tuple(z0, z1), release) → F
eqt(lock, pid(z0)) → F
eqt(true, true) → T
eqt(pid(z0), lock) → F
eqt(pending, resource) → F
eqt(resource, pending) → F
eqt(lock, false) → F
eqt(resource, nil) → F
eqt(excl, locker) → F
eqt(locker, excl) → F
eqt(tag, pid(z0)) → F
eqt(pid(z0), tag) → F
eqt(a, false) → F
eqt(pending, ok) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(locker, ok) → F
eqt(tag, tuplenil(z0)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuplenil(z0), tag) → F
eqt(a, mcrlrecord) → F
eqt(mcrlrecord, a) → F
eqt(false, tuple(z0, z1)) → F
eqt(tuple(z0, z1), false) → F
eqt(excl, pending) → F
eqt(pending, excl) → F
eqt(nil, tuplenil(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(tuplenil(z0), nil) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tag, mcrlrecord) → F
eqt(ok, int(z0)) → F
eqt(int(z0), ok) → F
eqt(tuple(z0, z1), undefined) → F
eqt(request, release) → F
eqt(mcrlrecord, mcrlrecord) → T
eqt(a, pid(z0)) → F
eqt(tag, release) → F
eqt(pid(z0), a) → F
eqt(nil, tuple(z0, z1)) → F
eqt(tuple(z0, z1), nil) → F
eqt(request, tag) → F
eqt(tag, request) → F
eqt(true, undefined) → F
eqt(lock, tuplenil(z0)) → F
eqt(tuplenil(z0), lock) → F
eqt(pid(z0), mcrlrecord) → F
eqt(a, tuplenil(z0)) → F
eqt(tuplenil(z0), a) → F
eqt(request, tuplenil(z0)) → F
eqt(tuplenil(z0), request) → F
eqt(locker, undefined) → F
eqt(resource, true) → F
eqt(true, resource) → F
eqt(ok, cons(z0, z1)) → F
eqt(true, pid(z0)) → F
eqt(pid(z0), true) → F
eqt(excl, pid(z0)) → F
eqt(mcrlrecord, resource) → F
eqt(resource, mcrlrecord) → F
eqt(pid(z0), excl) → F
eqt(int(z0), false) → F
eqt(false, cons(z0, z1)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(int(z0), excl) → F
eqt(true, false) → F
eqt(true, mcrlrecord) → F
eqt(resource, pid(z0)) → F
eqt(pid(z0), resource) → F
eqt(excl, resource) → F
eqt(resource, excl) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(true, int(z0)) → F
eqt(int(z0), true) → F
eqt(resource, int(z0)) → F
eqt(int(z0), resource) → F
eqt(excl, nil) → F
eqt(tag, undefined) → F
eqt(ok, undefined) → F
eqt(resource, false) → F
eqt(locker, cons(z0, z1)) → F
eqt(excl, mcrlrecord) → F
eqt(mcrlrecord, excl) → F
eqt(request, true) → F
eqt(true, request) → F
eqt(nil, cons(z0, z1)) → F
eqt(resource, tag) → F
eqt(tag, resource) → F
eqt(pid(z0), undefined) → F
eqt(int(z0), release) → F
eqt(excl, true) → F
eqt(resource, resource) → T
eqt(true, excl) → F
eqt(pending, tuple(z0, z1)) → F
eqt(tuple(z0, z1), pending) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tag, int(z0)) → F
eqt(int(z0), tag) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(excl, false) → F
eqt(request, resource) → F
eqt(resource, request) → F
eqt(nil, undefined) → F
eqt(undefined, nil) → F
eqt(lock, undefined) → F
eqt(true, tuplenil(z0)) → F
eqt(tuplenil(z0), true) → F
eqt(locker, tuple(z0, z1)) → F
eqt(tuple(z0, z1), locker) → F
eqt(resource, tuplenil(z0)) → F
eqt(tuplenil(z0), resource) → F
eqt(excl, release) → F
eqt(release, excl) → F
eqt(a, excl) → F
eqt(excl, a) → F
eqt(int(z0), mcrlrecord) → F
eqt(excl, request) → F
locker2_map_add_pending(nil, z0, z1) → nil
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
record_updates(z0, z1, nil) → z0
record_updates(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → record_updates(record_update(z0, z1, z2, z3), z1, z4)
gen_tag(z0) → tuple(z0, tuplenil(tag))
istops(z0, stack(z1, z2)) → eqt(z0, z1)
istops(z0, empty) → F
locker2_map_promote_pending(nil, z0) → nil
locker2_map_promote_pending(cons(z0, z1), z2) → cons(locker2_promote_pending(z0, z2), locker2_map_promote_pending(z1, z2))
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(0)), tuplenil(z0)) → z0
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
case0(z0, z1, z2) → z1
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(empty, empty) → T
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
locker2_map_claim_lock(nil, z0, z1) → nil
locker2_map_claim_lock(cons(z0, z1), z2, z3) → cons(locker2_claim_lock(z0, z2, z3), locker2_map_claim_lock(z1, z2, z3))
case1(z0, z1, z2, false) → z2
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
locker2_adduniq(nil, z0) → z0
case6(z0, z1, z2, true) → andt(equal(record_extract(z1, lock, excl), nil), equal(record_extract(z1, lock, pending), nil))
case6(z0, z1, z2, false) → locker2_check_available(z2, z0)
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
case5(z0, z1, z2, true) → andt(locker2_obtainable(z2, z0), locker2_obtainables(z1, z0))
case5(z0, z1, z2, false) → locker2_obtainables(z1, z0)
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_check_availables(nil, z0) → true
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
case8(z0, z1, z2, true) → z0
eqc(nocalls, nocalls) → T
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
or(F, F) → F
or(F, T) → T
or(T, F) → T
or(T, T) → T
imp(F, z0) → T
imp(T, z0) → z0
gen_modtageq(z0, z1) → equal(z0, z1)
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
eq(F, F) → T
eq(T, T) → T
eq(T, F) → F
eq(F, T) → F
locker2_check_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
pushs(z0, z1) → stack(z0, z1)
case4(z0, z1, z2) → false
if(T, z0, z1) → z0
if(F, z0, z1) → z1
not(F) → T
not(T) → F
tops(stack(z0, z1)) → z0
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
pops(stack(z0, z1)) → z1
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))

Tuples:

EQT(tuple(z0, z1), tuple(z2, z3)) → c50(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c276(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4), RECORD_UPDATE(z0, z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_PROMOTE_PENDING(z0, z2), LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
PUSH(z0, z1, calls(z2, z3, z4)) → c311(PUSH1(z0, z1, z2, z3, z4, eqt(z0, z2)), EQT(z0, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(AND(eqt(z0, z2), eqs(z1, z3)), EQT(z0, z2), EQS(z1, z3))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)), APPEND(record_extract(z2, lock, pending), cons(z0, nil)), RECORD_EXTRACT(z2, lock, pending))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2), DELETE(z1, z0))
LOCKER2_REMOVE_PENDING(z0, z1) → c334(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)), SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)), RECORD_EXTRACT(z0, lock, pending))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLE(z0, z2), LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(AND(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5))), EQT(z0, z3), AND(eqs(z1, z4), eqc(z2, z5)), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)), MEMBER(record_extract(z0, lock, resource), z1), RECORD_EXTRACT(z0, lock, resource))

S tuples:

EQT(tuple(z0, z1), tuple(z2, z3)) → c50(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c276(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4), RECORD_UPDATE(z0, z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_PROMOTE_PENDING(z0, z2), LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
PUSH(z0, z1, calls(z2, z3, z4)) → c311(PUSH1(z0, z1, z2, z3, z4, eqt(z0, z2)), EQT(z0, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(AND(eqt(z0, z2), eqs(z1, z3)), EQT(z0, z2), EQS(z1, z3))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)), APPEND(record_extract(z2, lock, pending), cons(z0, nil)), RECORD_EXTRACT(z2, lock, pending))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2), DELETE(z1, z0))
LOCKER2_REMOVE_PENDING(z0, z1) → c334(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)), SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)), RECORD_EXTRACT(z0, lock, pending))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLE(z0, z2), LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(AND(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5))), EQT(z0, z3), AND(eqs(z1, z4), eqc(z2, z5)), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)), MEMBER(record_extract(z0, lock, resource), z1), RECORD_EXTRACT(z0, lock, resource))

K tuples:none
Defined Rule Symbols:

eqt, locker2_map_add_pending, locker2_obtainables, record_updates, gen_tag, istops, locker2_map_promote_pending, append, case9, element, push, case0, eqs, locker2_release_lock, locker2_map_claim_lock, case1, record_update, push1, locker2_promote_pending, delete, locker2_adduniq, case6, subtract, locker2_remove_pending, case5, locker2_check_availables, case8, eqc, or, imp, gen_modtageq, and, eq, locker2_check_available, member, record_extract, record_new, pushs, case4, if, not, tops, case2, pops, locker2_add_pending

Defined Pair Symbols:

EQT, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, APPEND, ELEMENT, PUSH, EQS, LOCKER2_MAP_CLAIM_LOCK, CASE1, SUBTRACT, LOCKER2_REMOVE_PENDING, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING

Compound Symbols:

c50, c70, c135, c276, c299, c304, c305, c308, c311, c315, c321, c323, c332, c334, c337, c342, c375

(7) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID) transformation)

Removed 15 trailing tuple parts

(8) Obligation:

Complexity Dependency Tuples Problem
Rules:

eqt(locker, release) → F
eqt(release, locker) → F
eqt(mcrlrecord, release) → F
eqt(release, mcrlrecord) → F
eqt(pending, undefined) → F
eqt(release, false) → F
eqt(a, int(z0)) → F
eqt(int(z0), a) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tuple(z0, z1), tag) → F
eqt(request, undefined) → F
eqt(a, a) → T
eqt(false, tuplenil(z0)) → F
eqt(lock, resource) → F
eqt(resource, lock) → F
eqt(tuplenil(z0), false) → F
eqt(excl, tag) → F
eqt(lock, ok) → F
eqt(tag, excl) → F
eqt(a, resource) → F
eqt(resource, a) → F
eqt(pending, pid(z0)) → F
eqt(pid(z0), pending) → F
eqt(pending, pending) → T
eqt(request, request) → T
eqt(excl, lock) → F
eqt(lock, excl) → F
eqt(a, nil) → F
eqt(pending, true) → F
eqt(true, pending) → F
eqt(tuple(z0, z1), excl) → F
eqt(nil, pid(z0)) → F
eqt(pid(z0), nil) → F
eqt(lock, cons(z0, z1)) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(ok, tuple(z0, z1)) → F
eqt(tuple(z0, z1), ok) → F
eqt(lock, int(z0)) → F
eqt(locker, pending) → F
eqt(pending, locker) → F
eqt(true, release) → F
eqt(int(z0), lock) → F
eqt(mcrlrecord, request) → F
eqt(request, mcrlrecord) → F
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(excl, ok) → F
eqt(undefined, tuplenil(z0)) → F
eqt(tuplenil(z0), undefined) → F
eqt(int(z0), undefined) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuplenil(z0), release) → F
eqt(a, request) → F
eqt(resource, undefined) → F
eqt(lock, request) → F
eqt(pid(z0), int(z1)) → F
eqt(mcrlrecord, nil) → F
eqt(tag, cons(z0, z1)) → F
eqt(cons(z0, z1), tag) → F
eqt(locker, nil) → F
eqt(a, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(pid(z0), release) → F
eqt(tuple(z0, z1), lock) → F
eqt(true, nil) → F
eqt(a, release) → F
eqt(release, a) → F
eqt(mcrlrecord, false) → F
eqt(request, pid(z0)) → F
eqt(pid(z0), request) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
eqt(a, tag) → F
eqt(tag, a) → F
eqt(pending, release) → F
eqt(pid(z0), false) → F
eqt(ok, pid(z0)) → F
eqt(pid(z0), ok) → F
eqt(excl, undefined) → F
eqt(true, cons(z0, z1)) → F
eqt(cons(z0, z1), true) → F
eqt(pending, tuplenil(z0)) → F
eqt(tuplenil(z0), pending) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(locker, resource) → F
eqt(ok, resource) → F
eqt(resource, locker) → F
eqt(resource, ok) → F
eqt(pending, tag) → F
eqt(tag, pending) → F
eqt(a, lock) → F
eqt(lock, a) → F
eqt(request, tuple(z0, z1)) → F
eqt(tuple(z0, z1), request) → F
eqt(lock, release) → F
eqt(release, lock) → F
eqt(tag, tag) → T
eqt(resource, cons(z0, z1)) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), undefined) → F
eqt(lock, tag) → F
eqt(tag, lock) → F
eqt(release, nil) → F
eqt(locker, pid(z0)) → F
eqt(pid(z0), locker) → F
eqt(tag, nil) → F
eqt(ok, true) → F
eqt(true, ok) → F
eqt(lock, pending) → F
eqt(locker, false) → F
eqt(pending, lock) → F
eqt(a, tuple(z0, z1)) → F
eqt(locker, int(z0)) → F
eqt(int(z0), locker) → F
eqt(tuple(z0, z1), a) → F
eqt(lock, nil) → F
eqt(lock, lock) → T
eqt(a, locker) → F
eqt(a, pending) → F
eqt(locker, a) → F
eqt(pending, a) → F
eqt(true, tuple(z0, z1)) → F
eqt(tuple(z0, z1), true) → F
eqt(pending, request) → F
eqt(request, pending) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(a, ok) → F
eqt(request, ok) → F
eqt(locker, mcrlrecord) → F
eqt(mcrlrecord, locker) → F
eqt(mcrlrecord, ok) → F
eqt(pending, false) → F
eqt(locker, request) → F
eqt(ok, tag) → F
eqt(tag, ok) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(resource, tuple(z0, z1)) → F
eqt(tuple(z0, z1), resource) → F
eqt(locker, true) → F
eqt(true, locker) → F
eqt(mcrlrecord, pending) → F
eqt(pending, mcrlrecord) → F
eqt(locker, tuplenil(z0)) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), excl) → F
eqt(a, undefined) → F
eqt(undefined, a) → F
eqt(release, ok) → F
eqt(request, int(z0)) → F
eqt(int(z0), request) → F
eqt(locker, locker) → T
eqt(lock, true) → F
eqt(true, lock) → F
eqt(lock, mcrlrecord) → F
eqt(mcrlrecord, lock) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, int(z0)) → F
eqt(int(z0), pending) → F
eqt(tag, false) → F
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(pending, nil) → F
eqt(tag, true) → F
eqt(true, tag) → F
eqt(lock, locker) → F
eqt(locker, lock) → F
eqt(resource, release) → F
eqt(excl, excl) → T
eqt(nil, int(z0)) → F
eqt(int(z0), nil) → F
eqt(ok, tuplenil(z0)) → F
eqt(tuplenil(z0), ok) → F
eqt(a, true) → F
eqt(true, a) → F
eqt(locker, tag) → F
eqt(tag, locker) → F
eqt(tuple(z0, z1), release) → F
eqt(lock, pid(z0)) → F
eqt(true, true) → T
eqt(pid(z0), lock) → F
eqt(pending, resource) → F
eqt(resource, pending) → F
eqt(lock, false) → F
eqt(resource, nil) → F
eqt(excl, locker) → F
eqt(locker, excl) → F
eqt(tag, pid(z0)) → F
eqt(pid(z0), tag) → F
eqt(a, false) → F
eqt(pending, ok) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(locker, ok) → F
eqt(tag, tuplenil(z0)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuplenil(z0), tag) → F
eqt(a, mcrlrecord) → F
eqt(mcrlrecord, a) → F
eqt(false, tuple(z0, z1)) → F
eqt(tuple(z0, z1), false) → F
eqt(excl, pending) → F
eqt(pending, excl) → F
eqt(nil, tuplenil(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(tuplenil(z0), nil) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tag, mcrlrecord) → F
eqt(ok, int(z0)) → F
eqt(int(z0), ok) → F
eqt(tuple(z0, z1), undefined) → F
eqt(request, release) → F
eqt(mcrlrecord, mcrlrecord) → T
eqt(a, pid(z0)) → F
eqt(tag, release) → F
eqt(pid(z0), a) → F
eqt(nil, tuple(z0, z1)) → F
eqt(tuple(z0, z1), nil) → F
eqt(request, tag) → F
eqt(tag, request) → F
eqt(true, undefined) → F
eqt(lock, tuplenil(z0)) → F
eqt(tuplenil(z0), lock) → F
eqt(pid(z0), mcrlrecord) → F
eqt(a, tuplenil(z0)) → F
eqt(tuplenil(z0), a) → F
eqt(request, tuplenil(z0)) → F
eqt(tuplenil(z0), request) → F
eqt(locker, undefined) → F
eqt(resource, true) → F
eqt(true, resource) → F
eqt(ok, cons(z0, z1)) → F
eqt(true, pid(z0)) → F
eqt(pid(z0), true) → F
eqt(excl, pid(z0)) → F
eqt(mcrlrecord, resource) → F
eqt(resource, mcrlrecord) → F
eqt(pid(z0), excl) → F
eqt(int(z0), false) → F
eqt(false, cons(z0, z1)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(int(z0), excl) → F
eqt(true, false) → F
eqt(true, mcrlrecord) → F
eqt(resource, pid(z0)) → F
eqt(pid(z0), resource) → F
eqt(excl, resource) → F
eqt(resource, excl) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(true, int(z0)) → F
eqt(int(z0), true) → F
eqt(resource, int(z0)) → F
eqt(int(z0), resource) → F
eqt(excl, nil) → F
eqt(tag, undefined) → F
eqt(ok, undefined) → F
eqt(resource, false) → F
eqt(locker, cons(z0, z1)) → F
eqt(excl, mcrlrecord) → F
eqt(mcrlrecord, excl) → F
eqt(request, true) → F
eqt(true, request) → F
eqt(nil, cons(z0, z1)) → F
eqt(resource, tag) → F
eqt(tag, resource) → F
eqt(pid(z0), undefined) → F
eqt(int(z0), release) → F
eqt(excl, true) → F
eqt(resource, resource) → T
eqt(true, excl) → F
eqt(pending, tuple(z0, z1)) → F
eqt(tuple(z0, z1), pending) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tag, int(z0)) → F
eqt(int(z0), tag) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(excl, false) → F
eqt(request, resource) → F
eqt(resource, request) → F
eqt(nil, undefined) → F
eqt(undefined, nil) → F
eqt(lock, undefined) → F
eqt(true, tuplenil(z0)) → F
eqt(tuplenil(z0), true) → F
eqt(locker, tuple(z0, z1)) → F
eqt(tuple(z0, z1), locker) → F
eqt(resource, tuplenil(z0)) → F
eqt(tuplenil(z0), resource) → F
eqt(excl, release) → F
eqt(release, excl) → F
eqt(a, excl) → F
eqt(excl, a) → F
eqt(int(z0), mcrlrecord) → F
eqt(excl, request) → F
locker2_map_add_pending(nil, z0, z1) → nil
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
record_updates(z0, z1, nil) → z0
record_updates(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → record_updates(record_update(z0, z1, z2, z3), z1, z4)
gen_tag(z0) → tuple(z0, tuplenil(tag))
istops(z0, stack(z1, z2)) → eqt(z0, z1)
istops(z0, empty) → F
locker2_map_promote_pending(nil, z0) → nil
locker2_map_promote_pending(cons(z0, z1), z2) → cons(locker2_promote_pending(z0, z2), locker2_map_promote_pending(z1, z2))
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(0)), tuplenil(z0)) → z0
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
case0(z0, z1, z2) → z1
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(empty, empty) → T
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
locker2_map_claim_lock(nil, z0, z1) → nil
locker2_map_claim_lock(cons(z0, z1), z2, z3) → cons(locker2_claim_lock(z0, z2, z3), locker2_map_claim_lock(z1, z2, z3))
case1(z0, z1, z2, false) → z2
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
locker2_adduniq(nil, z0) → z0
case6(z0, z1, z2, true) → andt(equal(record_extract(z1, lock, excl), nil), equal(record_extract(z1, lock, pending), nil))
case6(z0, z1, z2, false) → locker2_check_available(z2, z0)
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
case5(z0, z1, z2, true) → andt(locker2_obtainable(z2, z0), locker2_obtainables(z1, z0))
case5(z0, z1, z2, false) → locker2_obtainables(z1, z0)
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_check_availables(nil, z0) → true
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
case8(z0, z1, z2, true) → z0
eqc(nocalls, nocalls) → T
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
or(F, F) → F
or(F, T) → T
or(T, F) → T
or(T, T) → T
imp(F, z0) → T
imp(T, z0) → z0
gen_modtageq(z0, z1) → equal(z0, z1)
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
eq(F, F) → T
eq(T, T) → T
eq(T, F) → F
eq(F, T) → F
locker2_check_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
pushs(z0, z1) → stack(z0, z1)
case4(z0, z1, z2) → false
if(T, z0, z1) → z0
if(F, z0, z1) → z1
not(F) → T
not(T) → F
tops(stack(z0, z1)) → z0
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
pops(stack(z0, z1)) → z1
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
PUSH(z0, z1, calls(z2, z3, z4)) → c311(EQT(z0, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_REMOVE_PENDING(z0, z1) → c334(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)), SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
PUSH(z0, z1, calls(z2, z3, z4)) → c311(EQT(z0, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_REMOVE_PENDING(z0, z1) → c334(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)), SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))

K tuples:none
Defined Rule Symbols:

eqt, locker2_map_add_pending, locker2_obtainables, record_updates, gen_tag, istops, locker2_map_promote_pending, append, case9, element, push, case0, eqs, locker2_release_lock, locker2_map_claim_lock, case1, record_update, push1, locker2_promote_pending, delete, locker2_adduniq, case6, subtract, locker2_remove_pending, case5, locker2_check_availables, case8, eqc, or, imp, gen_modtageq, and, eq, locker2_check_available, member, record_extract, record_new, pushs, case4, if, not, tops, case2, pops, locker2_add_pending

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, PUSH, EQS, CASE1, SUBTRACT, LOCKER2_REMOVE_PENDING, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c311, c315, c323, c332, c334, c337, c342, c375

(9) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID) transformation)

Split RHS of tuples not part of any SCC

(10) Obligation:

Complexity Dependency Tuples Problem
Rules:

eqt(locker, release) → F
eqt(release, locker) → F
eqt(mcrlrecord, release) → F
eqt(release, mcrlrecord) → F
eqt(pending, undefined) → F
eqt(release, false) → F
eqt(a, int(z0)) → F
eqt(int(z0), a) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tuple(z0, z1), tag) → F
eqt(request, undefined) → F
eqt(a, a) → T
eqt(false, tuplenil(z0)) → F
eqt(lock, resource) → F
eqt(resource, lock) → F
eqt(tuplenil(z0), false) → F
eqt(excl, tag) → F
eqt(lock, ok) → F
eqt(tag, excl) → F
eqt(a, resource) → F
eqt(resource, a) → F
eqt(pending, pid(z0)) → F
eqt(pid(z0), pending) → F
eqt(pending, pending) → T
eqt(request, request) → T
eqt(excl, lock) → F
eqt(lock, excl) → F
eqt(a, nil) → F
eqt(pending, true) → F
eqt(true, pending) → F
eqt(tuple(z0, z1), excl) → F
eqt(nil, pid(z0)) → F
eqt(pid(z0), nil) → F
eqt(lock, cons(z0, z1)) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(ok, tuple(z0, z1)) → F
eqt(tuple(z0, z1), ok) → F
eqt(lock, int(z0)) → F
eqt(locker, pending) → F
eqt(pending, locker) → F
eqt(true, release) → F
eqt(int(z0), lock) → F
eqt(mcrlrecord, request) → F
eqt(request, mcrlrecord) → F
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(excl, ok) → F
eqt(undefined, tuplenil(z0)) → F
eqt(tuplenil(z0), undefined) → F
eqt(int(z0), undefined) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuplenil(z0), release) → F
eqt(a, request) → F
eqt(resource, undefined) → F
eqt(lock, request) → F
eqt(pid(z0), int(z1)) → F
eqt(mcrlrecord, nil) → F
eqt(tag, cons(z0, z1)) → F
eqt(cons(z0, z1), tag) → F
eqt(locker, nil) → F
eqt(a, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(pid(z0), release) → F
eqt(tuple(z0, z1), lock) → F
eqt(true, nil) → F
eqt(a, release) → F
eqt(release, a) → F
eqt(mcrlrecord, false) → F
eqt(request, pid(z0)) → F
eqt(pid(z0), request) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
eqt(a, tag) → F
eqt(tag, a) → F
eqt(pending, release) → F
eqt(pid(z0), false) → F
eqt(ok, pid(z0)) → F
eqt(pid(z0), ok) → F
eqt(excl, undefined) → F
eqt(true, cons(z0, z1)) → F
eqt(cons(z0, z1), true) → F
eqt(pending, tuplenil(z0)) → F
eqt(tuplenil(z0), pending) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(locker, resource) → F
eqt(ok, resource) → F
eqt(resource, locker) → F
eqt(resource, ok) → F
eqt(pending, tag) → F
eqt(tag, pending) → F
eqt(a, lock) → F
eqt(lock, a) → F
eqt(request, tuple(z0, z1)) → F
eqt(tuple(z0, z1), request) → F
eqt(lock, release) → F
eqt(release, lock) → F
eqt(tag, tag) → T
eqt(resource, cons(z0, z1)) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), undefined) → F
eqt(lock, tag) → F
eqt(tag, lock) → F
eqt(release, nil) → F
eqt(locker, pid(z0)) → F
eqt(pid(z0), locker) → F
eqt(tag, nil) → F
eqt(ok, true) → F
eqt(true, ok) → F
eqt(lock, pending) → F
eqt(locker, false) → F
eqt(pending, lock) → F
eqt(a, tuple(z0, z1)) → F
eqt(locker, int(z0)) → F
eqt(int(z0), locker) → F
eqt(tuple(z0, z1), a) → F
eqt(lock, nil) → F
eqt(lock, lock) → T
eqt(a, locker) → F
eqt(a, pending) → F
eqt(locker, a) → F
eqt(pending, a) → F
eqt(true, tuple(z0, z1)) → F
eqt(tuple(z0, z1), true) → F
eqt(pending, request) → F
eqt(request, pending) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(a, ok) → F
eqt(request, ok) → F
eqt(locker, mcrlrecord) → F
eqt(mcrlrecord, locker) → F
eqt(mcrlrecord, ok) → F
eqt(pending, false) → F
eqt(locker, request) → F
eqt(ok, tag) → F
eqt(tag, ok) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(resource, tuple(z0, z1)) → F
eqt(tuple(z0, z1), resource) → F
eqt(locker, true) → F
eqt(true, locker) → F
eqt(mcrlrecord, pending) → F
eqt(pending, mcrlrecord) → F
eqt(locker, tuplenil(z0)) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), excl) → F
eqt(a, undefined) → F
eqt(undefined, a) → F
eqt(release, ok) → F
eqt(request, int(z0)) → F
eqt(int(z0), request) → F
eqt(locker, locker) → T
eqt(lock, true) → F
eqt(true, lock) → F
eqt(lock, mcrlrecord) → F
eqt(mcrlrecord, lock) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, int(z0)) → F
eqt(int(z0), pending) → F
eqt(tag, false) → F
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(pending, nil) → F
eqt(tag, true) → F
eqt(true, tag) → F
eqt(lock, locker) → F
eqt(locker, lock) → F
eqt(resource, release) → F
eqt(excl, excl) → T
eqt(nil, int(z0)) → F
eqt(int(z0), nil) → F
eqt(ok, tuplenil(z0)) → F
eqt(tuplenil(z0), ok) → F
eqt(a, true) → F
eqt(true, a) → F
eqt(locker, tag) → F
eqt(tag, locker) → F
eqt(tuple(z0, z1), release) → F
eqt(lock, pid(z0)) → F
eqt(true, true) → T
eqt(pid(z0), lock) → F
eqt(pending, resource) → F
eqt(resource, pending) → F
eqt(lock, false) → F
eqt(resource, nil) → F
eqt(excl, locker) → F
eqt(locker, excl) → F
eqt(tag, pid(z0)) → F
eqt(pid(z0), tag) → F
eqt(a, false) → F
eqt(pending, ok) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(locker, ok) → F
eqt(tag, tuplenil(z0)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuplenil(z0), tag) → F
eqt(a, mcrlrecord) → F
eqt(mcrlrecord, a) → F
eqt(false, tuple(z0, z1)) → F
eqt(tuple(z0, z1), false) → F
eqt(excl, pending) → F
eqt(pending, excl) → F
eqt(nil, tuplenil(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(tuplenil(z0), nil) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tag, mcrlrecord) → F
eqt(ok, int(z0)) → F
eqt(int(z0), ok) → F
eqt(tuple(z0, z1), undefined) → F
eqt(request, release) → F
eqt(mcrlrecord, mcrlrecord) → T
eqt(a, pid(z0)) → F
eqt(tag, release) → F
eqt(pid(z0), a) → F
eqt(nil, tuple(z0, z1)) → F
eqt(tuple(z0, z1), nil) → F
eqt(request, tag) → F
eqt(tag, request) → F
eqt(true, undefined) → F
eqt(lock, tuplenil(z0)) → F
eqt(tuplenil(z0), lock) → F
eqt(pid(z0), mcrlrecord) → F
eqt(a, tuplenil(z0)) → F
eqt(tuplenil(z0), a) → F
eqt(request, tuplenil(z0)) → F
eqt(tuplenil(z0), request) → F
eqt(locker, undefined) → F
eqt(resource, true) → F
eqt(true, resource) → F
eqt(ok, cons(z0, z1)) → F
eqt(true, pid(z0)) → F
eqt(pid(z0), true) → F
eqt(excl, pid(z0)) → F
eqt(mcrlrecord, resource) → F
eqt(resource, mcrlrecord) → F
eqt(pid(z0), excl) → F
eqt(int(z0), false) → F
eqt(false, cons(z0, z1)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(int(z0), excl) → F
eqt(true, false) → F
eqt(true, mcrlrecord) → F
eqt(resource, pid(z0)) → F
eqt(pid(z0), resource) → F
eqt(excl, resource) → F
eqt(resource, excl) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(true, int(z0)) → F
eqt(int(z0), true) → F
eqt(resource, int(z0)) → F
eqt(int(z0), resource) → F
eqt(excl, nil) → F
eqt(tag, undefined) → F
eqt(ok, undefined) → F
eqt(resource, false) → F
eqt(locker, cons(z0, z1)) → F
eqt(excl, mcrlrecord) → F
eqt(mcrlrecord, excl) → F
eqt(request, true) → F
eqt(true, request) → F
eqt(nil, cons(z0, z1)) → F
eqt(resource, tag) → F
eqt(tag, resource) → F
eqt(pid(z0), undefined) → F
eqt(int(z0), release) → F
eqt(excl, true) → F
eqt(resource, resource) → T
eqt(true, excl) → F
eqt(pending, tuple(z0, z1)) → F
eqt(tuple(z0, z1), pending) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tag, int(z0)) → F
eqt(int(z0), tag) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(excl, false) → F
eqt(request, resource) → F
eqt(resource, request) → F
eqt(nil, undefined) → F
eqt(undefined, nil) → F
eqt(lock, undefined) → F
eqt(true, tuplenil(z0)) → F
eqt(tuplenil(z0), true) → F
eqt(locker, tuple(z0, z1)) → F
eqt(tuple(z0, z1), locker) → F
eqt(resource, tuplenil(z0)) → F
eqt(tuplenil(z0), resource) → F
eqt(excl, release) → F
eqt(release, excl) → F
eqt(a, excl) → F
eqt(excl, a) → F
eqt(int(z0), mcrlrecord) → F
eqt(excl, request) → F
locker2_map_add_pending(nil, z0, z1) → nil
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
record_updates(z0, z1, nil) → z0
record_updates(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → record_updates(record_update(z0, z1, z2, z3), z1, z4)
gen_tag(z0) → tuple(z0, tuplenil(tag))
istops(z0, stack(z1, z2)) → eqt(z0, z1)
istops(z0, empty) → F
locker2_map_promote_pending(nil, z0) → nil
locker2_map_promote_pending(cons(z0, z1), z2) → cons(locker2_promote_pending(z0, z2), locker2_map_promote_pending(z1, z2))
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(0)), tuplenil(z0)) → z0
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
case0(z0, z1, z2) → z1
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(empty, empty) → T
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
locker2_map_claim_lock(nil, z0, z1) → nil
locker2_map_claim_lock(cons(z0, z1), z2, z3) → cons(locker2_claim_lock(z0, z2, z3), locker2_map_claim_lock(z1, z2, z3))
case1(z0, z1, z2, false) → z2
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
locker2_adduniq(nil, z0) → z0
case6(z0, z1, z2, true) → andt(equal(record_extract(z1, lock, excl), nil), equal(record_extract(z1, lock, pending), nil))
case6(z0, z1, z2, false) → locker2_check_available(z2, z0)
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
case5(z0, z1, z2, true) → andt(locker2_obtainable(z2, z0), locker2_obtainables(z1, z0))
case5(z0, z1, z2, false) → locker2_obtainables(z1, z0)
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_check_availables(nil, z0) → true
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
case8(z0, z1, z2, true) → z0
eqc(nocalls, nocalls) → T
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
or(F, F) → F
or(F, T) → T
or(T, F) → T
or(T, T) → T
imp(F, z0) → T
imp(T, z0) → z0
gen_modtageq(z0, z1) → equal(z0, z1)
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
eq(F, F) → T
eq(T, T) → T
eq(T, F) → F
eq(F, T) → F
locker2_check_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
pushs(z0, z1) → stack(z0, z1)
case4(z0, z1, z2) → false
if(T, z0, z1) → z0
if(F, z0, z1) → z1
not(F) → T
not(T) → F
tops(stack(z0, z1)) → z0
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
pops(stack(z0, z1)) → z1
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
PUSH(z0, z1, calls(z2, z3, z4)) → c311(EQT(z0, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
PUSH(z0, z1, calls(z2, z3, z4)) → c311(EQT(z0, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

K tuples:none
Defined Rule Symbols:

eqt, locker2_map_add_pending, locker2_obtainables, record_updates, gen_tag, istops, locker2_map_promote_pending, append, case9, element, push, case0, eqs, locker2_release_lock, locker2_map_claim_lock, case1, record_update, push1, locker2_promote_pending, delete, locker2_adduniq, case6, subtract, locker2_remove_pending, case5, locker2_check_availables, case8, eqc, or, imp, gen_modtageq, and, eq, locker2_check_available, member, record_extract, record_new, pushs, case4, if, not, tops, case2, pops, locker2_add_pending

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, PUSH, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c311, c315, c323, c332, c337, c342, c375, c

(11) CdtLeafRemovalProof (ComplexityIfPolyImplication transformation)

Removed 1 leading nodes:

PUSH(z0, z1, calls(z2, z3, z4)) → c311(EQT(z0, z2))

(12) Obligation:

Complexity Dependency Tuples Problem
Rules:

eqt(locker, release) → F
eqt(release, locker) → F
eqt(mcrlrecord, release) → F
eqt(release, mcrlrecord) → F
eqt(pending, undefined) → F
eqt(release, false) → F
eqt(a, int(z0)) → F
eqt(int(z0), a) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tuple(z0, z1), tag) → F
eqt(request, undefined) → F
eqt(a, a) → T
eqt(false, tuplenil(z0)) → F
eqt(lock, resource) → F
eqt(resource, lock) → F
eqt(tuplenil(z0), false) → F
eqt(excl, tag) → F
eqt(lock, ok) → F
eqt(tag, excl) → F
eqt(a, resource) → F
eqt(resource, a) → F
eqt(pending, pid(z0)) → F
eqt(pid(z0), pending) → F
eqt(pending, pending) → T
eqt(request, request) → T
eqt(excl, lock) → F
eqt(lock, excl) → F
eqt(a, nil) → F
eqt(pending, true) → F
eqt(true, pending) → F
eqt(tuple(z0, z1), excl) → F
eqt(nil, pid(z0)) → F
eqt(pid(z0), nil) → F
eqt(lock, cons(z0, z1)) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(ok, tuple(z0, z1)) → F
eqt(tuple(z0, z1), ok) → F
eqt(lock, int(z0)) → F
eqt(locker, pending) → F
eqt(pending, locker) → F
eqt(true, release) → F
eqt(int(z0), lock) → F
eqt(mcrlrecord, request) → F
eqt(request, mcrlrecord) → F
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(excl, ok) → F
eqt(undefined, tuplenil(z0)) → F
eqt(tuplenil(z0), undefined) → F
eqt(int(z0), undefined) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuplenil(z0), release) → F
eqt(a, request) → F
eqt(resource, undefined) → F
eqt(lock, request) → F
eqt(pid(z0), int(z1)) → F
eqt(mcrlrecord, nil) → F
eqt(tag, cons(z0, z1)) → F
eqt(cons(z0, z1), tag) → F
eqt(locker, nil) → F
eqt(a, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(pid(z0), release) → F
eqt(tuple(z0, z1), lock) → F
eqt(true, nil) → F
eqt(a, release) → F
eqt(release, a) → F
eqt(mcrlrecord, false) → F
eqt(request, pid(z0)) → F
eqt(pid(z0), request) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
eqt(a, tag) → F
eqt(tag, a) → F
eqt(pending, release) → F
eqt(pid(z0), false) → F
eqt(ok, pid(z0)) → F
eqt(pid(z0), ok) → F
eqt(excl, undefined) → F
eqt(true, cons(z0, z1)) → F
eqt(cons(z0, z1), true) → F
eqt(pending, tuplenil(z0)) → F
eqt(tuplenil(z0), pending) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(locker, resource) → F
eqt(ok, resource) → F
eqt(resource, locker) → F
eqt(resource, ok) → F
eqt(pending, tag) → F
eqt(tag, pending) → F
eqt(a, lock) → F
eqt(lock, a) → F
eqt(request, tuple(z0, z1)) → F
eqt(tuple(z0, z1), request) → F
eqt(lock, release) → F
eqt(release, lock) → F
eqt(tag, tag) → T
eqt(resource, cons(z0, z1)) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), undefined) → F
eqt(lock, tag) → F
eqt(tag, lock) → F
eqt(release, nil) → F
eqt(locker, pid(z0)) → F
eqt(pid(z0), locker) → F
eqt(tag, nil) → F
eqt(ok, true) → F
eqt(true, ok) → F
eqt(lock, pending) → F
eqt(locker, false) → F
eqt(pending, lock) → F
eqt(a, tuple(z0, z1)) → F
eqt(locker, int(z0)) → F
eqt(int(z0), locker) → F
eqt(tuple(z0, z1), a) → F
eqt(lock, nil) → F
eqt(lock, lock) → T
eqt(a, locker) → F
eqt(a, pending) → F
eqt(locker, a) → F
eqt(pending, a) → F
eqt(true, tuple(z0, z1)) → F
eqt(tuple(z0, z1), true) → F
eqt(pending, request) → F
eqt(request, pending) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(a, ok) → F
eqt(request, ok) → F
eqt(locker, mcrlrecord) → F
eqt(mcrlrecord, locker) → F
eqt(mcrlrecord, ok) → F
eqt(pending, false) → F
eqt(locker, request) → F
eqt(ok, tag) → F
eqt(tag, ok) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(resource, tuple(z0, z1)) → F
eqt(tuple(z0, z1), resource) → F
eqt(locker, true) → F
eqt(true, locker) → F
eqt(mcrlrecord, pending) → F
eqt(pending, mcrlrecord) → F
eqt(locker, tuplenil(z0)) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), excl) → F
eqt(a, undefined) → F
eqt(undefined, a) → F
eqt(release, ok) → F
eqt(request, int(z0)) → F
eqt(int(z0), request) → F
eqt(locker, locker) → T
eqt(lock, true) → F
eqt(true, lock) → F
eqt(lock, mcrlrecord) → F
eqt(mcrlrecord, lock) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, int(z0)) → F
eqt(int(z0), pending) → F
eqt(tag, false) → F
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(pending, nil) → F
eqt(tag, true) → F
eqt(true, tag) → F
eqt(lock, locker) → F
eqt(locker, lock) → F
eqt(resource, release) → F
eqt(excl, excl) → T
eqt(nil, int(z0)) → F
eqt(int(z0), nil) → F
eqt(ok, tuplenil(z0)) → F
eqt(tuplenil(z0), ok) → F
eqt(a, true) → F
eqt(true, a) → F
eqt(locker, tag) → F
eqt(tag, locker) → F
eqt(tuple(z0, z1), release) → F
eqt(lock, pid(z0)) → F
eqt(true, true) → T
eqt(pid(z0), lock) → F
eqt(pending, resource) → F
eqt(resource, pending) → F
eqt(lock, false) → F
eqt(resource, nil) → F
eqt(excl, locker) → F
eqt(locker, excl) → F
eqt(tag, pid(z0)) → F
eqt(pid(z0), tag) → F
eqt(a, false) → F
eqt(pending, ok) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(locker, ok) → F
eqt(tag, tuplenil(z0)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuplenil(z0), tag) → F
eqt(a, mcrlrecord) → F
eqt(mcrlrecord, a) → F
eqt(false, tuple(z0, z1)) → F
eqt(tuple(z0, z1), false) → F
eqt(excl, pending) → F
eqt(pending, excl) → F
eqt(nil, tuplenil(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(tuplenil(z0), nil) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tag, mcrlrecord) → F
eqt(ok, int(z0)) → F
eqt(int(z0), ok) → F
eqt(tuple(z0, z1), undefined) → F
eqt(request, release) → F
eqt(mcrlrecord, mcrlrecord) → T
eqt(a, pid(z0)) → F
eqt(tag, release) → F
eqt(pid(z0), a) → F
eqt(nil, tuple(z0, z1)) → F
eqt(tuple(z0, z1), nil) → F
eqt(request, tag) → F
eqt(tag, request) → F
eqt(true, undefined) → F
eqt(lock, tuplenil(z0)) → F
eqt(tuplenil(z0), lock) → F
eqt(pid(z0), mcrlrecord) → F
eqt(a, tuplenil(z0)) → F
eqt(tuplenil(z0), a) → F
eqt(request, tuplenil(z0)) → F
eqt(tuplenil(z0), request) → F
eqt(locker, undefined) → F
eqt(resource, true) → F
eqt(true, resource) → F
eqt(ok, cons(z0, z1)) → F
eqt(true, pid(z0)) → F
eqt(pid(z0), true) → F
eqt(excl, pid(z0)) → F
eqt(mcrlrecord, resource) → F
eqt(resource, mcrlrecord) → F
eqt(pid(z0), excl) → F
eqt(int(z0), false) → F
eqt(false, cons(z0, z1)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(int(z0), excl) → F
eqt(true, false) → F
eqt(true, mcrlrecord) → F
eqt(resource, pid(z0)) → F
eqt(pid(z0), resource) → F
eqt(excl, resource) → F
eqt(resource, excl) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(true, int(z0)) → F
eqt(int(z0), true) → F
eqt(resource, int(z0)) → F
eqt(int(z0), resource) → F
eqt(excl, nil) → F
eqt(tag, undefined) → F
eqt(ok, undefined) → F
eqt(resource, false) → F
eqt(locker, cons(z0, z1)) → F
eqt(excl, mcrlrecord) → F
eqt(mcrlrecord, excl) → F
eqt(request, true) → F
eqt(true, request) → F
eqt(nil, cons(z0, z1)) → F
eqt(resource, tag) → F
eqt(tag, resource) → F
eqt(pid(z0), undefined) → F
eqt(int(z0), release) → F
eqt(excl, true) → F
eqt(resource, resource) → T
eqt(true, excl) → F
eqt(pending, tuple(z0, z1)) → F
eqt(tuple(z0, z1), pending) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tag, int(z0)) → F
eqt(int(z0), tag) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(excl, false) → F
eqt(request, resource) → F
eqt(resource, request) → F
eqt(nil, undefined) → F
eqt(undefined, nil) → F
eqt(lock, undefined) → F
eqt(true, tuplenil(z0)) → F
eqt(tuplenil(z0), true) → F
eqt(locker, tuple(z0, z1)) → F
eqt(tuple(z0, z1), locker) → F
eqt(resource, tuplenil(z0)) → F
eqt(tuplenil(z0), resource) → F
eqt(excl, release) → F
eqt(release, excl) → F
eqt(a, excl) → F
eqt(excl, a) → F
eqt(int(z0), mcrlrecord) → F
eqt(excl, request) → F
locker2_map_add_pending(nil, z0, z1) → nil
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
record_updates(z0, z1, nil) → z0
record_updates(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → record_updates(record_update(z0, z1, z2, z3), z1, z4)
gen_tag(z0) → tuple(z0, tuplenil(tag))
istops(z0, stack(z1, z2)) → eqt(z0, z1)
istops(z0, empty) → F
locker2_map_promote_pending(nil, z0) → nil
locker2_map_promote_pending(cons(z0, z1), z2) → cons(locker2_promote_pending(z0, z2), locker2_map_promote_pending(z1, z2))
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(0)), tuplenil(z0)) → z0
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
case0(z0, z1, z2) → z1
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(empty, empty) → T
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
locker2_map_claim_lock(nil, z0, z1) → nil
locker2_map_claim_lock(cons(z0, z1), z2, z3) → cons(locker2_claim_lock(z0, z2, z3), locker2_map_claim_lock(z1, z2, z3))
case1(z0, z1, z2, false) → z2
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
locker2_adduniq(nil, z0) → z0
case6(z0, z1, z2, true) → andt(equal(record_extract(z1, lock, excl), nil), equal(record_extract(z1, lock, pending), nil))
case6(z0, z1, z2, false) → locker2_check_available(z2, z0)
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
case5(z0, z1, z2, true) → andt(locker2_obtainable(z2, z0), locker2_obtainables(z1, z0))
case5(z0, z1, z2, false) → locker2_obtainables(z1, z0)
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_check_availables(nil, z0) → true
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
case8(z0, z1, z2, true) → z0
eqc(nocalls, nocalls) → T
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
or(F, F) → F
or(F, T) → T
or(T, F) → T
or(T, T) → T
imp(F, z0) → T
imp(T, z0) → z0
gen_modtageq(z0, z1) → equal(z0, z1)
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
eq(F, F) → T
eq(T, T) → T
eq(T, F) → F
eq(F, T) → F
locker2_check_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
pushs(z0, z1) → stack(z0, z1)
case4(z0, z1, z2) → false
if(T, z0, z1) → z0
if(F, z0, z1) → z1
not(F) → T
not(T) → F
tops(stack(z0, z1)) → z0
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
pops(stack(z0, z1)) → z1
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

K tuples:none
Defined Rule Symbols:

eqt, locker2_map_add_pending, locker2_obtainables, record_updates, gen_tag, istops, locker2_map_promote_pending, append, case9, element, push, case0, eqs, locker2_release_lock, locker2_map_claim_lock, case1, record_update, push1, locker2_promote_pending, delete, locker2_adduniq, case6, subtract, locker2_remove_pending, case5, locker2_check_availables, case8, eqc, or, imp, gen_modtageq, and, eq, locker2_check_available, member, record_extract, record_new, pushs, case4, if, not, tops, case2, pops, locker2_add_pending

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(13) CdtKnowledgeProof (BOTH BOUNDS(ID, ID) transformation)

The following tuples could be moved from S to K by knowledge propagation:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))

(14) Obligation:

Complexity Dependency Tuples Problem
Rules:

eqt(locker, release) → F
eqt(release, locker) → F
eqt(mcrlrecord, release) → F
eqt(release, mcrlrecord) → F
eqt(pending, undefined) → F
eqt(release, false) → F
eqt(a, int(z0)) → F
eqt(int(z0), a) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tuple(z0, z1), tag) → F
eqt(request, undefined) → F
eqt(a, a) → T
eqt(false, tuplenil(z0)) → F
eqt(lock, resource) → F
eqt(resource, lock) → F
eqt(tuplenil(z0), false) → F
eqt(excl, tag) → F
eqt(lock, ok) → F
eqt(tag, excl) → F
eqt(a, resource) → F
eqt(resource, a) → F
eqt(pending, pid(z0)) → F
eqt(pid(z0), pending) → F
eqt(pending, pending) → T
eqt(request, request) → T
eqt(excl, lock) → F
eqt(lock, excl) → F
eqt(a, nil) → F
eqt(pending, true) → F
eqt(true, pending) → F
eqt(tuple(z0, z1), excl) → F
eqt(nil, pid(z0)) → F
eqt(pid(z0), nil) → F
eqt(lock, cons(z0, z1)) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(ok, tuple(z0, z1)) → F
eqt(tuple(z0, z1), ok) → F
eqt(lock, int(z0)) → F
eqt(locker, pending) → F
eqt(pending, locker) → F
eqt(true, release) → F
eqt(int(z0), lock) → F
eqt(mcrlrecord, request) → F
eqt(request, mcrlrecord) → F
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(excl, ok) → F
eqt(undefined, tuplenil(z0)) → F
eqt(tuplenil(z0), undefined) → F
eqt(int(z0), undefined) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuplenil(z0), release) → F
eqt(a, request) → F
eqt(resource, undefined) → F
eqt(lock, request) → F
eqt(pid(z0), int(z1)) → F
eqt(mcrlrecord, nil) → F
eqt(tag, cons(z0, z1)) → F
eqt(cons(z0, z1), tag) → F
eqt(locker, nil) → F
eqt(a, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(pid(z0), release) → F
eqt(tuple(z0, z1), lock) → F
eqt(true, nil) → F
eqt(a, release) → F
eqt(release, a) → F
eqt(mcrlrecord, false) → F
eqt(request, pid(z0)) → F
eqt(pid(z0), request) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
eqt(a, tag) → F
eqt(tag, a) → F
eqt(pending, release) → F
eqt(pid(z0), false) → F
eqt(ok, pid(z0)) → F
eqt(pid(z0), ok) → F
eqt(excl, undefined) → F
eqt(true, cons(z0, z1)) → F
eqt(cons(z0, z1), true) → F
eqt(pending, tuplenil(z0)) → F
eqt(tuplenil(z0), pending) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(locker, resource) → F
eqt(ok, resource) → F
eqt(resource, locker) → F
eqt(resource, ok) → F
eqt(pending, tag) → F
eqt(tag, pending) → F
eqt(a, lock) → F
eqt(lock, a) → F
eqt(request, tuple(z0, z1)) → F
eqt(tuple(z0, z1), request) → F
eqt(lock, release) → F
eqt(release, lock) → F
eqt(tag, tag) → T
eqt(resource, cons(z0, z1)) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), undefined) → F
eqt(lock, tag) → F
eqt(tag, lock) → F
eqt(release, nil) → F
eqt(locker, pid(z0)) → F
eqt(pid(z0), locker) → F
eqt(tag, nil) → F
eqt(ok, true) → F
eqt(true, ok) → F
eqt(lock, pending) → F
eqt(locker, false) → F
eqt(pending, lock) → F
eqt(a, tuple(z0, z1)) → F
eqt(locker, int(z0)) → F
eqt(int(z0), locker) → F
eqt(tuple(z0, z1), a) → F
eqt(lock, nil) → F
eqt(lock, lock) → T
eqt(a, locker) → F
eqt(a, pending) → F
eqt(locker, a) → F
eqt(pending, a) → F
eqt(true, tuple(z0, z1)) → F
eqt(tuple(z0, z1), true) → F
eqt(pending, request) → F
eqt(request, pending) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(a, ok) → F
eqt(request, ok) → F
eqt(locker, mcrlrecord) → F
eqt(mcrlrecord, locker) → F
eqt(mcrlrecord, ok) → F
eqt(pending, false) → F
eqt(locker, request) → F
eqt(ok, tag) → F
eqt(tag, ok) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(resource, tuple(z0, z1)) → F
eqt(tuple(z0, z1), resource) → F
eqt(locker, true) → F
eqt(true, locker) → F
eqt(mcrlrecord, pending) → F
eqt(pending, mcrlrecord) → F
eqt(locker, tuplenil(z0)) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), excl) → F
eqt(a, undefined) → F
eqt(undefined, a) → F
eqt(release, ok) → F
eqt(request, int(z0)) → F
eqt(int(z0), request) → F
eqt(locker, locker) → T
eqt(lock, true) → F
eqt(true, lock) → F
eqt(lock, mcrlrecord) → F
eqt(mcrlrecord, lock) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, int(z0)) → F
eqt(int(z0), pending) → F
eqt(tag, false) → F
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(pending, nil) → F
eqt(tag, true) → F
eqt(true, tag) → F
eqt(lock, locker) → F
eqt(locker, lock) → F
eqt(resource, release) → F
eqt(excl, excl) → T
eqt(nil, int(z0)) → F
eqt(int(z0), nil) → F
eqt(ok, tuplenil(z0)) → F
eqt(tuplenil(z0), ok) → F
eqt(a, true) → F
eqt(true, a) → F
eqt(locker, tag) → F
eqt(tag, locker) → F
eqt(tuple(z0, z1), release) → F
eqt(lock, pid(z0)) → F
eqt(true, true) → T
eqt(pid(z0), lock) → F
eqt(pending, resource) → F
eqt(resource, pending) → F
eqt(lock, false) → F
eqt(resource, nil) → F
eqt(excl, locker) → F
eqt(locker, excl) → F
eqt(tag, pid(z0)) → F
eqt(pid(z0), tag) → F
eqt(a, false) → F
eqt(pending, ok) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(locker, ok) → F
eqt(tag, tuplenil(z0)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuplenil(z0), tag) → F
eqt(a, mcrlrecord) → F
eqt(mcrlrecord, a) → F
eqt(false, tuple(z0, z1)) → F
eqt(tuple(z0, z1), false) → F
eqt(excl, pending) → F
eqt(pending, excl) → F
eqt(nil, tuplenil(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(tuplenil(z0), nil) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tag, mcrlrecord) → F
eqt(ok, int(z0)) → F
eqt(int(z0), ok) → F
eqt(tuple(z0, z1), undefined) → F
eqt(request, release) → F
eqt(mcrlrecord, mcrlrecord) → T
eqt(a, pid(z0)) → F
eqt(tag, release) → F
eqt(pid(z0), a) → F
eqt(nil, tuple(z0, z1)) → F
eqt(tuple(z0, z1), nil) → F
eqt(request, tag) → F
eqt(tag, request) → F
eqt(true, undefined) → F
eqt(lock, tuplenil(z0)) → F
eqt(tuplenil(z0), lock) → F
eqt(pid(z0), mcrlrecord) → F
eqt(a, tuplenil(z0)) → F
eqt(tuplenil(z0), a) → F
eqt(request, tuplenil(z0)) → F
eqt(tuplenil(z0), request) → F
eqt(locker, undefined) → F
eqt(resource, true) → F
eqt(true, resource) → F
eqt(ok, cons(z0, z1)) → F
eqt(true, pid(z0)) → F
eqt(pid(z0), true) → F
eqt(excl, pid(z0)) → F
eqt(mcrlrecord, resource) → F
eqt(resource, mcrlrecord) → F
eqt(pid(z0), excl) → F
eqt(int(z0), false) → F
eqt(false, cons(z0, z1)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(int(z0), excl) → F
eqt(true, false) → F
eqt(true, mcrlrecord) → F
eqt(resource, pid(z0)) → F
eqt(pid(z0), resource) → F
eqt(excl, resource) → F
eqt(resource, excl) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(true, int(z0)) → F
eqt(int(z0), true) → F
eqt(resource, int(z0)) → F
eqt(int(z0), resource) → F
eqt(excl, nil) → F
eqt(tag, undefined) → F
eqt(ok, undefined) → F
eqt(resource, false) → F
eqt(locker, cons(z0, z1)) → F
eqt(excl, mcrlrecord) → F
eqt(mcrlrecord, excl) → F
eqt(request, true) → F
eqt(true, request) → F
eqt(nil, cons(z0, z1)) → F
eqt(resource, tag) → F
eqt(tag, resource) → F
eqt(pid(z0), undefined) → F
eqt(int(z0), release) → F
eqt(excl, true) → F
eqt(resource, resource) → T
eqt(true, excl) → F
eqt(pending, tuple(z0, z1)) → F
eqt(tuple(z0, z1), pending) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tag, int(z0)) → F
eqt(int(z0), tag) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(excl, false) → F
eqt(request, resource) → F
eqt(resource, request) → F
eqt(nil, undefined) → F
eqt(undefined, nil) → F
eqt(lock, undefined) → F
eqt(true, tuplenil(z0)) → F
eqt(tuplenil(z0), true) → F
eqt(locker, tuple(z0, z1)) → F
eqt(tuple(z0, z1), locker) → F
eqt(resource, tuplenil(z0)) → F
eqt(tuplenil(z0), resource) → F
eqt(excl, release) → F
eqt(release, excl) → F
eqt(a, excl) → F
eqt(excl, a) → F
eqt(int(z0), mcrlrecord) → F
eqt(excl, request) → F
locker2_map_add_pending(nil, z0, z1) → nil
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
record_updates(z0, z1, nil) → z0
record_updates(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → record_updates(record_update(z0, z1, z2, z3), z1, z4)
gen_tag(z0) → tuple(z0, tuplenil(tag))
istops(z0, stack(z1, z2)) → eqt(z0, z1)
istops(z0, empty) → F
locker2_map_promote_pending(nil, z0) → nil
locker2_map_promote_pending(cons(z0, z1), z2) → cons(locker2_promote_pending(z0, z2), locker2_map_promote_pending(z1, z2))
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(0)), tuplenil(z0)) → z0
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
case0(z0, z1, z2) → z1
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(empty, empty) → T
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
locker2_map_claim_lock(nil, z0, z1) → nil
locker2_map_claim_lock(cons(z0, z1), z2, z3) → cons(locker2_claim_lock(z0, z2, z3), locker2_map_claim_lock(z1, z2, z3))
case1(z0, z1, z2, false) → z2
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
locker2_adduniq(nil, z0) → z0
case6(z0, z1, z2, true) → andt(equal(record_extract(z1, lock, excl), nil), equal(record_extract(z1, lock, pending), nil))
case6(z0, z1, z2, false) → locker2_check_available(z2, z0)
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
case5(z0, z1, z2, true) → andt(locker2_obtainable(z2, z0), locker2_obtainables(z1, z0))
case5(z0, z1, z2, false) → locker2_obtainables(z1, z0)
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_check_availables(nil, z0) → true
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
case8(z0, z1, z2, true) → z0
eqc(nocalls, nocalls) → T
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
or(F, F) → F
or(F, T) → T
or(T, F) → T
or(T, T) → T
imp(F, z0) → T
imp(T, z0) → z0
gen_modtageq(z0, z1) → equal(z0, z1)
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
eq(F, F) → T
eq(T, T) → T
eq(T, F) → F
eq(F, T) → F
locker2_check_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
pushs(z0, z1) → stack(z0, z1)
case4(z0, z1, z2) → false
if(T, z0, z1) → z0
if(F, z0, z1) → z1
not(F) → T
not(T) → F
tops(stack(z0, z1)) → z0
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
pops(stack(z0, z1)) → z1
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))

Defined Rule Symbols:

eqt, locker2_map_add_pending, locker2_obtainables, record_updates, gen_tag, istops, locker2_map_promote_pending, append, case9, element, push, case0, eqs, locker2_release_lock, locker2_map_claim_lock, case1, record_update, push1, locker2_promote_pending, delete, locker2_adduniq, case6, subtract, locker2_remove_pending, case5, locker2_check_availables, case8, eqc, or, imp, gen_modtageq, and, eq, locker2_check_available, member, record_extract, record_new, pushs, case4, if, not, tops, case2, pops, locker2_add_pending

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(15) CdtUsableRulesProof (EQUIVALENT transformation)

The following rules are not usable and were removed:

eqt(locker, release) → F
eqt(release, locker) → F
eqt(mcrlrecord, release) → F
eqt(release, mcrlrecord) → F
eqt(pending, undefined) → F
eqt(release, false) → F
eqt(a, int(z0)) → F
eqt(int(z0), a) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tuple(z0, z1), tag) → F
eqt(request, undefined) → F
eqt(a, a) → T
eqt(false, tuplenil(z0)) → F
eqt(lock, resource) → F
eqt(resource, lock) → F
eqt(tuplenil(z0), false) → F
eqt(excl, tag) → F
eqt(lock, ok) → F
eqt(tag, excl) → F
eqt(a, resource) → F
eqt(resource, a) → F
eqt(pending, pid(z0)) → F
eqt(pid(z0), pending) → F
eqt(pending, pending) → T
eqt(request, request) → T
eqt(excl, lock) → F
eqt(lock, excl) → F
eqt(a, nil) → F
eqt(pending, true) → F
eqt(true, pending) → F
eqt(tuple(z0, z1), excl) → F
eqt(nil, pid(z0)) → F
eqt(pid(z0), nil) → F
eqt(lock, cons(z0, z1)) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(ok, tuple(z0, z1)) → F
eqt(tuple(z0, z1), ok) → F
eqt(lock, int(z0)) → F
eqt(locker, pending) → F
eqt(pending, locker) → F
eqt(true, release) → F
eqt(int(z0), lock) → F
eqt(mcrlrecord, request) → F
eqt(request, mcrlrecord) → F
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(excl, ok) → F
eqt(undefined, tuplenil(z0)) → F
eqt(tuplenil(z0), undefined) → F
eqt(int(z0), undefined) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuplenil(z0), release) → F
eqt(a, request) → F
eqt(resource, undefined) → F
eqt(lock, request) → F
eqt(pid(z0), int(z1)) → F
eqt(mcrlrecord, nil) → F
eqt(tag, cons(z0, z1)) → F
eqt(cons(z0, z1), tag) → F
eqt(locker, nil) → F
eqt(a, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(pid(z0), release) → F
eqt(tuple(z0, z1), lock) → F
eqt(true, nil) → F
eqt(a, release) → F
eqt(release, a) → F
eqt(mcrlrecord, false) → F
eqt(request, pid(z0)) → F
eqt(pid(z0), request) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
eqt(a, tag) → F
eqt(tag, a) → F
eqt(pending, release) → F
eqt(pid(z0), false) → F
eqt(ok, pid(z0)) → F
eqt(pid(z0), ok) → F
eqt(excl, undefined) → F
eqt(true, cons(z0, z1)) → F
eqt(cons(z0, z1), true) → F
eqt(pending, tuplenil(z0)) → F
eqt(tuplenil(z0), pending) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(locker, resource) → F
eqt(ok, resource) → F
eqt(resource, locker) → F
eqt(resource, ok) → F
eqt(pending, tag) → F
eqt(tag, pending) → F
eqt(a, lock) → F
eqt(lock, a) → F
eqt(request, tuple(z0, z1)) → F
eqt(tuple(z0, z1), request) → F
eqt(lock, release) → F
eqt(release, lock) → F
eqt(tag, tag) → T
eqt(resource, cons(z0, z1)) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), undefined) → F
eqt(lock, tag) → F
eqt(tag, lock) → F
eqt(release, nil) → F
eqt(locker, pid(z0)) → F
eqt(pid(z0), locker) → F
eqt(tag, nil) → F
eqt(ok, true) → F
eqt(true, ok) → F
eqt(lock, pending) → F
eqt(locker, false) → F
eqt(pending, lock) → F
eqt(a, tuple(z0, z1)) → F
eqt(locker, int(z0)) → F
eqt(int(z0), locker) → F
eqt(tuple(z0, z1), a) → F
eqt(lock, nil) → F
eqt(lock, lock) → T
eqt(a, locker) → F
eqt(a, pending) → F
eqt(locker, a) → F
eqt(pending, a) → F
eqt(true, tuple(z0, z1)) → F
eqt(tuple(z0, z1), true) → F
eqt(pending, request) → F
eqt(request, pending) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(a, ok) → F
eqt(request, ok) → F
eqt(locker, mcrlrecord) → F
eqt(mcrlrecord, locker) → F
eqt(mcrlrecord, ok) → F
eqt(pending, false) → F
eqt(locker, request) → F
eqt(ok, tag) → F
eqt(tag, ok) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(resource, tuple(z0, z1)) → F
eqt(tuple(z0, z1), resource) → F
eqt(locker, true) → F
eqt(true, locker) → F
eqt(mcrlrecord, pending) → F
eqt(pending, mcrlrecord) → F
eqt(locker, tuplenil(z0)) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), excl) → F
eqt(a, undefined) → F
eqt(undefined, a) → F
eqt(release, ok) → F
eqt(request, int(z0)) → F
eqt(int(z0), request) → F
eqt(locker, locker) → T
eqt(lock, true) → F
eqt(true, lock) → F
eqt(lock, mcrlrecord) → F
eqt(mcrlrecord, lock) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, int(z0)) → F
eqt(int(z0), pending) → F
eqt(tag, false) → F
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(pending, nil) → F
eqt(tag, true) → F
eqt(true, tag) → F
eqt(lock, locker) → F
eqt(locker, lock) → F
eqt(resource, release) → F
eqt(excl, excl) → T
eqt(nil, int(z0)) → F
eqt(int(z0), nil) → F
eqt(ok, tuplenil(z0)) → F
eqt(tuplenil(z0), ok) → F
eqt(a, true) → F
eqt(true, a) → F
eqt(locker, tag) → F
eqt(tag, locker) → F
eqt(tuple(z0, z1), release) → F
eqt(lock, pid(z0)) → F
eqt(true, true) → T
eqt(pid(z0), lock) → F
eqt(pending, resource) → F
eqt(resource, pending) → F
eqt(lock, false) → F
eqt(resource, nil) → F
eqt(excl, locker) → F
eqt(locker, excl) → F
eqt(tag, pid(z0)) → F
eqt(pid(z0), tag) → F
eqt(a, false) → F
eqt(pending, ok) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(locker, ok) → F
eqt(tag, tuplenil(z0)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuplenil(z0), tag) → F
eqt(a, mcrlrecord) → F
eqt(mcrlrecord, a) → F
eqt(false, tuple(z0, z1)) → F
eqt(tuple(z0, z1), false) → F
eqt(excl, pending) → F
eqt(pending, excl) → F
eqt(nil, tuplenil(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(tuplenil(z0), nil) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tag, mcrlrecord) → F
eqt(ok, int(z0)) → F
eqt(int(z0), ok) → F
eqt(tuple(z0, z1), undefined) → F
eqt(request, release) → F
eqt(mcrlrecord, mcrlrecord) → T
eqt(a, pid(z0)) → F
eqt(tag, release) → F
eqt(pid(z0), a) → F
eqt(nil, tuple(z0, z1)) → F
eqt(tuple(z0, z1), nil) → F
eqt(request, tag) → F
eqt(tag, request) → F
eqt(true, undefined) → F
eqt(lock, tuplenil(z0)) → F
eqt(tuplenil(z0), lock) → F
eqt(pid(z0), mcrlrecord) → F
eqt(a, tuplenil(z0)) → F
eqt(tuplenil(z0), a) → F
eqt(request, tuplenil(z0)) → F
eqt(tuplenil(z0), request) → F
eqt(locker, undefined) → F
eqt(resource, true) → F
eqt(true, resource) → F
eqt(ok, cons(z0, z1)) → F
eqt(true, pid(z0)) → F
eqt(pid(z0), true) → F
eqt(excl, pid(z0)) → F
eqt(mcrlrecord, resource) → F
eqt(resource, mcrlrecord) → F
eqt(pid(z0), excl) → F
eqt(int(z0), false) → F
eqt(false, cons(z0, z1)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(int(z0), excl) → F
eqt(true, false) → F
eqt(true, mcrlrecord) → F
eqt(resource, pid(z0)) → F
eqt(pid(z0), resource) → F
eqt(excl, resource) → F
eqt(resource, excl) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(true, int(z0)) → F
eqt(int(z0), true) → F
eqt(resource, int(z0)) → F
eqt(int(z0), resource) → F
eqt(excl, nil) → F
eqt(tag, undefined) → F
eqt(ok, undefined) → F
eqt(resource, false) → F
eqt(locker, cons(z0, z1)) → F
eqt(excl, mcrlrecord) → F
eqt(mcrlrecord, excl) → F
eqt(request, true) → F
eqt(true, request) → F
eqt(nil, cons(z0, z1)) → F
eqt(resource, tag) → F
eqt(tag, resource) → F
eqt(pid(z0), undefined) → F
eqt(int(z0), release) → F
eqt(excl, true) → F
eqt(resource, resource) → T
eqt(true, excl) → F
eqt(pending, tuple(z0, z1)) → F
eqt(tuple(z0, z1), pending) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tag, int(z0)) → F
eqt(int(z0), tag) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(excl, false) → F
eqt(request, resource) → F
eqt(resource, request) → F
eqt(nil, undefined) → F
eqt(undefined, nil) → F
eqt(lock, undefined) → F
eqt(true, tuplenil(z0)) → F
eqt(tuplenil(z0), true) → F
eqt(locker, tuple(z0, z1)) → F
eqt(tuple(z0, z1), locker) → F
eqt(resource, tuplenil(z0)) → F
eqt(tuplenil(z0), resource) → F
eqt(excl, release) → F
eqt(release, excl) → F
eqt(a, excl) → F
eqt(excl, a) → F
eqt(int(z0), mcrlrecord) → F
eqt(excl, request) → F
locker2_map_add_pending(nil, z0, z1) → nil
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
record_updates(z0, z1, nil) → z0
record_updates(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → record_updates(record_update(z0, z1, z2, z3), z1, z4)
gen_tag(z0) → tuple(z0, tuplenil(tag))
istops(z0, stack(z1, z2)) → eqt(z0, z1)
istops(z0, empty) → F
locker2_map_promote_pending(nil, z0) → nil
locker2_map_promote_pending(cons(z0, z1), z2) → cons(locker2_promote_pending(z0, z2), locker2_map_promote_pending(z1, z2))
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(0)), tuplenil(z0)) → z0
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
case0(z0, z1, z2) → z1
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(empty, empty) → T
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
locker2_map_claim_lock(nil, z0, z1) → nil
locker2_map_claim_lock(cons(z0, z1), z2, z3) → cons(locker2_claim_lock(z0, z2, z3), locker2_map_claim_lock(z1, z2, z3))
case1(z0, z1, z2, false) → z2
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
locker2_adduniq(nil, z0) → z0
case6(z0, z1, z2, true) → andt(equal(record_extract(z1, lock, excl), nil), equal(record_extract(z1, lock, pending), nil))
case6(z0, z1, z2, false) → locker2_check_available(z2, z0)
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
case5(z0, z1, z2, true) → andt(locker2_obtainable(z2, z0), locker2_obtainables(z1, z0))
case5(z0, z1, z2, false) → locker2_obtainables(z1, z0)
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_check_availables(nil, z0) → true
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
case8(z0, z1, z2, true) → z0
eqc(nocalls, nocalls) → T
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
or(F, F) → F
or(F, T) → T
or(T, F) → T
or(T, T) → T
imp(F, z0) → T
imp(T, z0) → z0
gen_modtageq(z0, z1) → equal(z0, z1)
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
eq(F, F) → T
eq(T, T) → T
eq(T, F) → F
eq(F, T) → F
locker2_check_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
pushs(z0, z1) → stack(z0, z1)
case4(z0, z1, z2) → false
if(T, z0, z1) → z0
if(F, z0, z1) → z1
not(F) → T
not(T) → F
tops(stack(z0, z1)) → z0
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
pops(stack(z0, z1)) → z1
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))

(16) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(17) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))

We considered the (Usable) Rules:none
And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = x₁
POL(CASE1(x₁, x₂, x₃, x₄)) = [1]
POL(ELEMENT(x₁, x₂)) = 0
POL(EQC(x₁, x₂)) = x₁ + x₂
POL(EQS(x₁, x₂)) = 0
POL(EQT(x₁, x₂)) = 0
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = [1] + x₁ + x₂ + x₃
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = x₁
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = x₁
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = x₁
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = [1] + x₂
POL(RECORD_UPDATES(x₁, x₂, x₃)) = 0
POL(SUBTRACT(x₁, x₂)) = 0
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = [1] + x₁ + x₂ + x₃
POL(case8(x₁, x₂, x₃, x₄)) = [1]
POL(case9(x₁, x₂, x₃, x₄)) = [1]
POL(cons(x₁, x₂)) = [1] + x₁ + x₂
POL(delete(x₁, x₂)) = [1] + x₁ + x₂
POL(equal(x₁, x₂)) = 0
POL(false) = [1]
POL(int(x₁)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = [1] + x₁ + x₂
POL(nil) = [1]
POL(pending) = [1]
POL(pid(x₁)) = 0
POL(record_extract(x₁, x₂, x₃)) = 0
POL(record_update(x₁, x₂, x₃, x₄)) = [1] + x₃ + x₄
POL(resource) = 0
POL(s(x₁)) = 0
POL(stack(x₁, x₂)) = 0
POL(subtract(x₁, x₂)) = 0
POL(true) = 0
POL(tuple(x₁, x₂)) = 0
POL(tuplenil(x₁)) = 0

(18) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(19) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))

We considered the (Usable) Rules:none
And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = 0
POL(CASE1(x₁, x₂, x₃, x₄)) = 0
POL(ELEMENT(x₁, x₂)) = 0
POL(EQC(x₁, x₂)) = x₂
POL(EQS(x₁, x₂)) = x₂
POL(EQT(x₁, x₂)) = 0
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = [1]
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = 0
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = [1] + x₂
POL(RECORD_UPDATES(x₁, x₂, x₃)) = 0
POL(SUBTRACT(x₁, x₂)) = [1]
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = [1] + x₂ + x₃
POL(case8(x₁, x₂, x₃, x₄)) = 0
POL(case9(x₁, x₂, x₃, x₄)) = x₄
POL(cons(x₁, x₂)) = x₁
POL(delete(x₁, x₂)) = [1]
POL(equal(x₁, x₂)) = x₂
POL(false) = 0
POL(int(x₁)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = x₂
POL(nil) = 0
POL(pending) = 0
POL(pid(x₁)) = 0
POL(record_extract(x₁, x₂, x₃)) = 0
POL(record_update(x₁, x₂, x₃, x₄)) = 0
POL(resource) = 0
POL(s(x₁)) = 0
POL(stack(x₁, x₂)) = [1] + x₁ + x₂
POL(subtract(x₁, x₂)) = 0
POL(true) = 0
POL(tuple(x₁, x₂)) = 0
POL(tuplenil(x₁)) = 0

(20) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(21) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))

We considered the (Usable) Rules:none
And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = 0
POL(CASE1(x₁, x₂, x₃, x₄)) = [1]
POL(ELEMENT(x₁, x₂)) = x₁
POL(EQC(x₁, x₂)) = 0
POL(EQS(x₁, x₂)) = 0
POL(EQT(x₁, x₂)) = 0
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = [1] + x₂
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = 0
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = x₁
POL(RECORD_UPDATES(x₁, x₂, x₃)) = 0
POL(SUBTRACT(x₁, x₂)) = 0
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = 0
POL(case8(x₁, x₂, x₃, x₄)) = 0
POL(case9(x₁, x₂, x₃, x₄)) = 0
POL(cons(x₁, x₂)) = x₁
POL(delete(x₁, x₂)) = 0
POL(equal(x₁, x₂)) = 0
POL(false) = [1]
POL(int(x₁)) = x₁
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = [1] + x₂
POL(nil) = [1]
POL(pending) = 0
POL(pid(x₁)) = 0
POL(record_extract(x₁, x₂, x₃)) = 0
POL(record_update(x₁, x₂, x₃, x₄)) = 0
POL(resource) = 0
POL(s(x₁)) = [1] + x₁
POL(stack(x₁, x₂)) = 0
POL(subtract(x₁, x₂)) = 0
POL(true) = 0
POL(tuple(x₁, x₂)) = 0
POL(tuplenil(x₁)) = 0

(22) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(23) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))

We considered the (Usable) Rules:

delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil

And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = 0
POL(CASE1(x₁, x₂, x₃, x₄)) = 0
POL(ELEMENT(x₁, x₂)) = 0
POL(EQC(x₁, x₂)) = x₁ + x₂
POL(EQS(x₁, x₂)) = [1]
POL(EQT(x₁, x₂)) = 0
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = [1] + x₁
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = x₁
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = [1] + x₁ + x₂
POL(RECORD_UPDATES(x₁, x₂, x₃)) = 0
POL(SUBTRACT(x₁, x₂)) = x₁ + x₂
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = [1] + x₃
POL(case8(x₁, x₂, x₃, x₄)) = 0
POL(case9(x₁, x₂, x₃, x₄)) = [1] + x₄
POL(cons(x₁, x₂)) = [1] + x₂
POL(delete(x₁, x₂)) = 0
POL(equal(x₁, x₂)) = [1]
POL(false) = 0
POL(int(x₁)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = [1] + x₂
POL(nil) = 0
POL(pending) = 0
POL(pid(x₁)) = 0
POL(record_extract(x₁, x₂, x₃)) = 0
POL(record_update(x₁, x₂, x₃, x₄)) = 0
POL(resource) = 0
POL(s(x₁)) = 0
POL(stack(x₁, x₂)) = 0
POL(subtract(x₁, x₂)) = 0
POL(true) = 0
POL(tuple(x₁, x₂)) = 0
POL(tuplenil(x₁)) = 0

(24) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(25) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))

We considered the (Usable) Rules:

delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil

And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = 0
POL(CASE1(x₁, x₂, x₃, x₄)) = [3]x₃
POL(ELEMENT(x₁, x₂)) = 0
POL(EQC(x₁, x₂)) = [2]x₁ + [2]x₂
POL(EQS(x₁, x₂)) = [1] + x₂
POL(EQT(x₁, x₂)) = x₂
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = [1] + [3]x₁ + [2]x₂ + x₃
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = 0
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = [1] + [2]x₁
POL(RECORD_UPDATES(x₁, x₂, x₃)) = 0
POL(SUBTRACT(x₁, x₂)) = [1] + x₁
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = [2] + x₁ + x₂ + x₃
POL(case8(x₁, x₂, x₃, x₄)) = 0
POL(case9(x₁, x₂, x₃, x₄)) = 0
POL(cons(x₁, x₂)) = x₁ + x₂
POL(delete(x₁, x₂)) = 0
POL(equal(x₁, x₂)) = 0
POL(false) = 0
POL(int(x₁)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = 0
POL(nil) = 0
POL(pending) = 0
POL(pid(x₁)) = [1] + x₁
POL(record_extract(x₁, x₂, x₃)) = [2]x₁ + x₃
POL(record_update(x₁, x₂, x₃, x₄)) = 0
POL(resource) = [1]
POL(s(x₁)) = 0
POL(stack(x₁, x₂)) = [2] + x₁ + x₂
POL(subtract(x₁, x₂)) = 0
POL(true) = 0
POL(tuple(x₁, x₂)) = x₁ + x₂
POL(tuplenil(x₁)) = x₁

(26) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(27) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))

We considered the (Usable) Rules:

delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil

And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = 0
POL(CASE1(x₁, x₂, x₃, x₄)) = 0
POL(ELEMENT(x₁, x₂)) = 0
POL(EQC(x₁, x₂)) = x₁ + x₂
POL(EQS(x₁, x₂)) = x₁ + x₂
POL(EQT(x₁, x₂)) = x₂
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = 0
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = 0
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = [1] + x₂
POL(RECORD_UPDATES(x₁, x₂, x₃)) = 0
POL(SUBTRACT(x₁, x₂)) = x₁
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(case8(x₁, x₂, x₃, x₄)) = x₂
POL(case9(x₁, x₂, x₃, x₄)) = [1] + x₄
POL(cons(x₁, x₂)) = x₁ + x₂
POL(delete(x₁, x₂)) = x₂
POL(equal(x₁, x₂)) = x₂
POL(false) = 0
POL(int(x₁)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = [1] + x₂
POL(nil) = 0
POL(pending) = 0
POL(pid(x₁)) = x₁
POL(record_extract(x₁, x₂, x₃)) = 0
POL(record_update(x₁, x₂, x₃, x₄)) = 0
POL(resource) = 0
POL(s(x₁)) = 0
POL(stack(x₁, x₂)) = [1] + x₁ + x₂
POL(subtract(x₁, x₂)) = 0
POL(true) = 0
POL(tuple(x₁, x₂)) = x₁ + x₂
POL(tuplenil(x₁)) = [1] + x₁

(28) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(29) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))

We considered the (Usable) Rules:none
And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = 0
POL(CASE1(x₁, x₂, x₃, x₄)) = [2]x₁ + x₂
POL(ELEMENT(x₁, x₂)) = 0
POL(EQC(x₁, x₂)) = [3]x₁ + [3]x₂
POL(EQS(x₁, x₂)) = [3]x₁ + [3]x₂
POL(EQT(x₁, x₂)) = x₁
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = [3] + x₂ + [3]x₃
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = x₁
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = x₁
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = x₁
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = [2] + [3]x₁ + [3]x₂
POL(RECORD_UPDATES(x₁, x₂, x₃)) = 0
POL(SUBTRACT(x₁, x₂)) = [1]
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(case8(x₁, x₂, x₃, x₄)) = 0
POL(case9(x₁, x₂, x₃, x₄)) = 0
POL(cons(x₁, x₂)) = [1] + x₁ + x₂
POL(delete(x₁, x₂)) = x₂
POL(equal(x₁, x₂)) = 0
POL(false) = 0
POL(int(x₁)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = 0
POL(nil) = 0
POL(pending) = 0
POL(pid(x₁)) = x₁
POL(record_extract(x₁, x₂, x₃)) = 0
POL(record_update(x₁, x₂, x₃, x₄)) = [2] + x₁ + [2]x₄
POL(resource) = 0
POL(s(x₁)) = 0
POL(stack(x₁, x₂)) = [3] + x₁ + x₂
POL(subtract(x₁, x₂)) = x₁
POL(true) = 0
POL(tuple(x₁, x₂)) = x₁ + x₂
POL(tuplenil(x₁)) = x₁

(30) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(31) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))

We considered the (Usable) Rules:none
And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = 0
POL(CASE1(x₁, x₂, x₃, x₄)) = x₁
POL(ELEMENT(x₁, x₂)) = 0
POL(EQC(x₁, x₂)) = x₁
POL(EQS(x₁, x₂)) = x₁
POL(EQT(x₁, x₂)) = x₁
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = x₁
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = x₁
POL(RECORD_UPDATES(x₁, x₂, x₃)) = 0
POL(SUBTRACT(x₁, x₂)) = 0
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(case8(x₁, x₂, x₃, x₄)) = 0
POL(case9(x₁, x₂, x₃, x₄)) = 0
POL(cons(x₁, x₂)) = x₁ + x₂
POL(delete(x₁, x₂)) = 0
POL(equal(x₁, x₂)) = 0
POL(false) = 0
POL(int(x₁)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = 0
POL(nil) = 0
POL(pending) = 0
POL(pid(x₁)) = x₁
POL(record_extract(x₁, x₂, x₃)) = 0
POL(record_update(x₁, x₂, x₃, x₄)) = 0
POL(resource) = 0
POL(s(x₁)) = 0
POL(stack(x₁, x₂)) = x₁ + x₂
POL(subtract(x₁, x₂)) = 0
POL(true) = 0
POL(tuple(x₁, x₂)) = [1] + x₁ + x₂
POL(tuplenil(x₁)) = x₁

(32) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:

RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))

K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(33) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.

RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))

We considered the (Usable) Rules:none
And the Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

The order we found is given by the following interpretation:
Polynomial interpretation :

POL(APPEND(x₁, x₂)) = 0
POL(CASE1(x₁, x₂, x₃, x₄)) = [1]
POL(ELEMENT(x₁, x₂)) = 0
POL(EQC(x₁, x₂)) = 0
POL(EQS(x₁, x₂)) = 0
POL(EQT(x₁, x₂)) = 0
POL(LOCKER2_ADD_PENDING(x₁, x₂, x₃)) = [1] + x₂ + x₃
POL(LOCKER2_CHECK_AVAILABLES(x₁, x₂)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x₁, x₂, x₃)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x₁, x₂)) = 0
POL(LOCKER2_REMOVE_PENDING(x₁, x₂)) = [1] + x₁ + x₂
POL(RECORD_UPDATES(x₁, x₂, x₃)) = x₃
POL(SUBTRACT(x₁, x₂)) = 0
POL(append(x₁, x₂)) = 0
POL(c(x₁)) = x₁
POL(c135(x₁)) = x₁
POL(c276(x₁, x₂)) = x₁ + x₂
POL(c299(x₁)) = x₁
POL(c304(x₁)) = x₁
POL(c305(x₁)) = x₁
POL(c308(x₁)) = x₁
POL(c315(x₁, x₂)) = x₁ + x₂
POL(c321(x₁)) = x₁
POL(c323(x₁)) = x₁
POL(c332(x₁)) = x₁
POL(c337(x₁)) = x₁
POL(c342(x₁, x₂, x₃)) = x₁ + x₂ + x₃
POL(c375(x₁)) = x₁
POL(c50(x₁, x₂)) = x₁ + x₂
POL(c70(x₁)) = x₁
POL(calls(x₁, x₂, x₃)) = 0
POL(case8(x₁, x₂, x₃, x₄)) = [1]
POL(case9(x₁, x₂, x₃, x₄)) = x₄
POL(cons(x₁, x₂)) = [1] + x₂
POL(delete(x₁, x₂)) = [1] + x₁
POL(equal(x₁, x₂)) = [1]
POL(false) = 0
POL(int(x₁)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x₁, x₂)) = [1] + x₁ + x₂
POL(nil) = 0
POL(pending) = 0
POL(pid(x₁)) = 0
POL(record_extract(x₁, x₂, x₃)) = 0
POL(record_update(x₁, x₂, x₃, x₄)) = 0
POL(resource) = 0
POL(s(x₁)) = 0
POL(stack(x₁, x₂)) = 0
POL(subtract(x₁, x₂)) = 0
POL(true) = 0
POL(tuple(x₁, x₂)) = 0
POL(tuplenil(x₁)) = 0

(34) Obligation:

Complexity Dependency Tuples Problem
Rules:

record_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
delete(z0, nil) → nil
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
member(z0, nil) → false
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0

Tuples:

EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))

S tuples:none
K tuples:

LOCKER2_ADD_PENDING(z0, z1, z2) → c375(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(RECORD_UPDATES(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil)))
LOCKER2_REMOVE_PENDING(z0, z1) → c(SUBTRACT(record_extract(z0, lock, pending), cons(z1, nil)))
CASE1(z0, z1, z2, true) → c323(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
APPEND(cons(z0, z1), z2) → c305(APPEND(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c321(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c304(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c337(LOCKER2_CHECK_AVAILABLES(z1, z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c342(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
EQS(stack(z0, z1), stack(z2, z3)) → c315(EQT(z0, z2), EQS(z1, z3))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c308(ELEMENT(int(s(z0)), z2))
SUBTRACT(z0, cons(z1, z2)) → c332(SUBTRACT(delete(z1, z0), z2))
EQT(pid(z0), pid(z1)) → c135(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c70(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c276(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c50(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c299(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))

Defined Rule Symbols:

record_update, delete, member, record_extract, subtract

Defined Pair Symbols:

EQT, APPEND, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, EQS, CASE1, SUBTRACT, LOCKER2_CHECK_AVAILABLES, EQC, LOCKER2_ADD_PENDING, LOCKER2_REMOVE_PENDING

Compound Symbols:

c70, c135, c305, c308, c321, c50, c276, c299, c304, c315, c323, c332, c337, c342, c375, c

(35) SIsEmptyProof (BOTH BOUNDS(ID, ID) transformation)

The set S is empty

(0) Obligation:

(1) NestedDefinedSymbolProof (BOTH BOUNDS(ID, ID) transformation)

(2) Obligation:

(3) CpxTrsToCdtProof (BOTH BOUNDS(ID, ID) transformation)

(4) Obligation:

(5) CdtLeafRemovalProof (ComplexityIfPolyImplication transformation)

(6) Obligation:

(7) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID) transformation)

(8) Obligation:

(9) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID) transformation)

(10) Obligation:

(11) CdtLeafRemovalProof (ComplexityIfPolyImplication transformation)

(12) Obligation:

(13) CdtKnowledgeProof (BOTH BOUNDS(ID, ID) transformation)

(14) Obligation:

(15) CdtUsableRulesProof (EQUIVALENT transformation)

(16) Obligation:

(17) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(18) Obligation:

(19) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(20) Obligation:

(21) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(22) Obligation:

(23) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(24) Obligation:

(25) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(26) Obligation:

(27) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(28) Obligation:

(29) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(30) Obligation:

(31) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(32) Obligation:

(33) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)) transformation)

(34) Obligation:

(35) SIsEmptyProof (BOTH BOUNDS(ID, ID) transformation)

(36) BOUNDS(1, 1)