(0) Obligation:
Runtime Complexity TRS:
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) CpxTrsToCdtProof (BOTH BOUNDS(ID, ID) transformation)
Converted Cpx (relative) TRS to CDT
(2) Obligation:
Complexity Dependency Tuples Problem
Rules:
or(T, T) → T
or(F, T) → T
or(T, F) → T
or(F, F) → F
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
imp(T, z0) → z0
imp(F, z0) → T
not(T) → F
not(F) → T
if(T, z0, z1) → z0
if(F, z0, z1) → z1
eq(T, T) → T
eq(F, F) → T
eq(T, F) → F
eq(F, T) → F
eqt(nil, undefined) → F
eqt(nil, pid(z0)) → F
eqt(nil, int(z0)) → F
eqt(nil, cons(z0, z1)) → F
eqt(nil, tuple(z0, z1)) → F
eqt(nil, tuplenil(z0)) → 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(z0)) → F
eqt(a, int(z0)) → F
eqt(a, cons(z0, z1)) → F
eqt(a, tuple(z0, z1)) → F
eqt(a, tuplenil(z0)) → 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(z0)) → F
eqt(excl, eqt(false, int(z0))) → F
eqt(false, cons(z0, z1)) → F
eqt(false, tuple(z0, z1)) → F
eqt(false, tuplenil(z0)) → 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(z0)) → F
eqt(lock, int(z0)) → F
eqt(lock, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(lock, tuplenil(z0)) → 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(z0)) → F
eqt(locker, int(z0)) → F
eqt(locker, cons(z0, z1)) → F
eqt(locker, tuple(z0, z1)) → F
eqt(locker, tuplenil(z0)) → 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(z0)) → F
eqt(ok, int(z0)) → F
eqt(ok, cons(z0, z1)) → F
eqt(ok, tuple(z0, z1)) → F
eqt(ok, tuplenil(z0)) → 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(z0)) → F
eqt(pending, int(z0)) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, tuple(z0, z1)) → F
eqt(pending, tuplenil(z0)) → 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(z0)) → F
eqt(request, int(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(request, tuple(z0, z1)) → F
eqt(request, tuplenil(z0)) → 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(z0)) → F
eqt(resource, int(z0)) → F
eqt(resource, cons(z0, z1)) → F
eqt(resource, tuple(z0, z1)) → F
eqt(resource, tuplenil(z0)) → 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(z0)) → F
eqt(tag, int(z0)) → F
eqt(tag, cons(z0, z1)) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tag, tuplenil(z0)) → 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(z0)) → F
eqt(true, int(z0)) → F
eqt(true, cons(z0, z1)) → F
eqt(true, tuple(z0, z1)) → F
eqt(true, tuplenil(z0)) → F
eqt(undefined, nil) → F
eqt(undefined, a) → F
eqt(undefined, tuplenil(z0)) → F
eqt(pid(z0), nil) → F
eqt(pid(z0), a) → F
eqt(pid(z0), excl) → F
eqt(pid(z0), false) → F
eqt(pid(z0), lock) → F
eqt(pid(z0), locker) → F
eqt(pid(z0), mcrlrecord) → F
eqt(pid(z0), ok) → F
eqt(pid(z0), pending) → F
eqt(pid(z0), release) → F
eqt(pid(z0), request) → F
eqt(pid(z0), resource) → F
eqt(pid(z0), tag) → F
eqt(pid(z0), true) → F
eqt(pid(z0), undefined) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(pid(z0), int(z1)) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(int(z0), nil) → F
eqt(int(z0), a) → F
eqt(int(z0), excl) → F
eqt(int(z0), false) → F
eqt(int(z0), lock) → F
eqt(int(z0), locker) → F
eqt(int(z0), mcrlrecord) → F
eqt(int(z0), ok) → F
eqt(int(z0), pending) → F
eqt(int(z0), release) → F
eqt(int(z0), request) → F
eqt(int(z0), resource) → F
eqt(int(z0), tag) → F
eqt(int(z0), true) → F
eqt(int(z0), undefined) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), tag) → F
eqt(cons(z0, z1), true) → F
eqt(cons(z0, z1), undefined) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuple(z0, z1), nil) → F
eqt(tuple(z0, z1), a) → F
eqt(tuple(z0, z1), excl) → F
eqt(tuple(z0, z1), false) → F
eqt(tuple(z0, z1), lock) → F
eqt(tuple(z0, z1), locker) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(tuple(z0, z1), ok) → F
eqt(tuple(z0, z1), pending) → F
eqt(tuple(z0, z1), release) → F
eqt(tuple(z0, z1), request) → F
eqt(tuple(z0, z1), resource) → F
eqt(tuple(z0, z1), tag) → F
eqt(tuple(z0, z1), true) → F
eqt(tuple(z0, z1), undefined) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), nil) → F
eqt(tuplenil(z0), a) → F
eqt(tuplenil(z0), excl) → F
eqt(tuplenil(z0), false) → F
eqt(tuplenil(z0), lock) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(tuplenil(z0), ok) → F
eqt(tuplenil(z0), pending) → F
eqt(tuplenil(z0), release) → F
eqt(tuplenil(z0), request) → F
eqt(tuplenil(z0), resource) → F
eqt(tuplenil(z0), tag) → F
eqt(tuplenil(z0), true) → F
eqt(tuplenil(z0), undefined) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
element(int(s(0)), tuplenil(z0)) → z0
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
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_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
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)
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))
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))
locker2_map_add_pending(nil, z0, z1) → nil
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
case0(z0, z1, z2) → z1
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
case1(z0, z1, z2, false) → z2
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
case4(z0, z1, z2) → false
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
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_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
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_check_availables(nil, z0) → true
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_adduniq(nil, z0) → z0
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
subtract(z0, nil) → z0
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
case8(z0, z1, z2, true) → z0
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
gen_tag(z0) → tuple(z0, tuplenil(tag))
gen_modtageq(z0, z1) → equal(z0, z1)
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
eqs(empty, empty) → T
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
pushs(z0, z1) → stack(z0, z1)
pops(stack(z0, z1)) → z1
tops(stack(z0, z1)) → z0
istops(z0, empty) → F
istops(z0, stack(z1, z2)) → eqt(z0, z1)
eqc(nocalls, nocalls) → T
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
Tuples:
OR(T, T) → c
OR(F, T) → c1
OR(T, F) → c2
OR(F, F) → c3
AND(T, z0) → c4
AND(z0, T) → c5
AND(F, z0) → c6
AND(z0, F) → c7
IMP(T, z0) → c8
IMP(F, z0) → c9
NOT(T) → c10
NOT(F) → c11
IF(T, z0, z1) → c12
IF(F, z0, z1) → c13
EQ(T, T) → c14
EQ(F, F) → c15
EQ(T, F) → c16
EQ(F, T) → c17
EQT(nil, undefined) → c18
EQT(nil, pid(z0)) → c19
EQT(nil, int(z0)) → c20
EQT(nil, cons(z0, z1)) → c21
EQT(nil, tuple(z0, z1)) → c22
EQT(nil, tuplenil(z0)) → c23
EQT(a, nil) → c24
EQT(a, a) → c25
EQT(a, excl) → c26
EQT(a, false) → c27
EQT(a, lock) → c28
EQT(a, locker) → c29
EQT(a, mcrlrecord) → c30
EQT(a, ok) → c31
EQT(a, pending) → c32
EQT(a, release) → c33
EQT(a, request) → c34
EQT(a, resource) → c35
EQT(a, tag) → c36
EQT(a, true) → c37
EQT(a, undefined) → c38
EQT(a, pid(z0)) → c39
EQT(a, int(z0)) → c40
EQT(a, cons(z0, z1)) → c41
EQT(a, tuple(z0, z1)) → c42
EQT(a, tuplenil(z0)) → c43
EQT(excl, nil) → c44
EQT(excl, a) → c45
EQT(excl, excl) → c46
EQT(excl, false) → c47
EQT(excl, lock) → c48
EQT(excl, locker) → c49
EQT(excl, mcrlrecord) → c50
EQT(excl, ok) → c51
EQT(excl, pending) → c52
EQT(excl, release) → c53
EQT(excl, request) → c54
EQT(excl, resource) → c55
EQT(excl, tag) → c56
EQT(excl, true) → c57
EQT(excl, undefined) → c58
EQT(excl, pid(z0)) → c59
EQT(excl, eqt(false, int(z0))) → c60
EQT(false, cons(z0, z1)) → c61
EQT(false, tuple(z0, z1)) → c62
EQT(false, tuplenil(z0)) → c63
EQT(lock, nil) → c64
EQT(lock, a) → c65
EQT(lock, excl) → c66
EQT(lock, false) → c67
EQT(lock, lock) → c68
EQT(lock, locker) → c69
EQT(lock, mcrlrecord) → c70
EQT(lock, ok) → c71
EQT(lock, pending) → c72
EQT(lock, release) → c73
EQT(lock, request) → c74
EQT(lock, resource) → c75
EQT(lock, tag) → c76
EQT(lock, true) → c77
EQT(lock, undefined) → c78
EQT(lock, pid(z0)) → c79
EQT(lock, int(z0)) → c80
EQT(lock, cons(z0, z1)) → c81
EQT(lock, tuple(z0, z1)) → c82
EQT(lock, tuplenil(z0)) → c83
EQT(locker, nil) → c84
EQT(locker, a) → c85
EQT(locker, excl) → c86
EQT(locker, false) → c87
EQT(locker, lock) → c88
EQT(locker, locker) → c89
EQT(locker, mcrlrecord) → c90
EQT(locker, ok) → c91
EQT(locker, pending) → c92
EQT(locker, release) → c93
EQT(locker, request) → c94
EQT(locker, resource) → c95
EQT(locker, tag) → c96
EQT(locker, true) → c97
EQT(locker, undefined) → c98
EQT(locker, pid(z0)) → c99
EQT(locker, int(z0)) → c100
EQT(locker, cons(z0, z1)) → c101
EQT(locker, tuple(z0, z1)) → c102
EQT(locker, tuplenil(z0)) → c103
EQT(mcrlrecord, nil) → c104
EQT(mcrlrecord, a) → c105
EQT(mcrlrecord, excl) → c106
EQT(mcrlrecord, false) → c107
EQT(mcrlrecord, lock) → c108
EQT(mcrlrecord, locker) → c109
EQT(mcrlrecord, mcrlrecord) → c110
EQT(mcrlrecord, ok) → c111
EQT(mcrlrecord, pending) → c112
EQT(mcrlrecord, release) → c113
EQT(mcrlrecord, request) → c114
EQT(mcrlrecord, resource) → c115
EQT(ok, resource) → c116
EQT(ok, tag) → c117
EQT(ok, true) → c118
EQT(ok, undefined) → c119
EQT(ok, pid(z0)) → c120
EQT(ok, int(z0)) → c121
EQT(ok, cons(z0, z1)) → c122
EQT(ok, tuple(z0, z1)) → c123
EQT(ok, tuplenil(z0)) → c124
EQT(pending, nil) → c125
EQT(pending, a) → c126
EQT(pending, excl) → c127
EQT(pending, false) → c128
EQT(pending, lock) → c129
EQT(pending, locker) → c130
EQT(pending, mcrlrecord) → c131
EQT(pending, ok) → c132
EQT(pending, pending) → c133
EQT(pending, release) → c134
EQT(pending, request) → c135
EQT(pending, resource) → c136
EQT(pending, tag) → c137
EQT(pending, true) → c138
EQT(pending, undefined) → c139
EQT(pending, pid(z0)) → c140
EQT(pending, int(z0)) → c141
EQT(pending, cons(z0, z1)) → c142
EQT(pending, tuple(z0, z1)) → c143
EQT(pending, tuplenil(z0)) → c144
EQT(release, nil) → c145
EQT(release, a) → c146
EQT(release, excl) → c147
EQT(release, false) → c148
EQT(release, lock) → c149
EQT(release, locker) → c150
EQT(release, mcrlrecord) → c151
EQT(release, ok) → c152
EQT(request, mcrlrecord) → c153
EQT(request, ok) → c154
EQT(request, pending) → c155
EQT(request, release) → c156
EQT(request, request) → c157
EQT(request, resource) → c158
EQT(request, tag) → c159
EQT(request, true) → c160
EQT(request, undefined) → c161
EQT(request, pid(z0)) → c162
EQT(request, int(z0)) → c163
EQT(request, cons(z0, z1)) → c164
EQT(request, tuple(z0, z1)) → c165
EQT(request, tuplenil(z0)) → c166
EQT(resource, nil) → c167
EQT(resource, a) → c168
EQT(resource, excl) → c169
EQT(resource, false) → c170
EQT(resource, lock) → c171
EQT(resource, locker) → c172
EQT(resource, mcrlrecord) → c173
EQT(resource, ok) → c174
EQT(resource, pending) → c175
EQT(resource, release) → c176
EQT(resource, request) → c177
EQT(resource, resource) → c178
EQT(resource, tag) → c179
EQT(resource, true) → c180
EQT(resource, undefined) → c181
EQT(resource, pid(z0)) → c182
EQT(resource, int(z0)) → c183
EQT(resource, cons(z0, z1)) → c184
EQT(resource, tuple(z0, z1)) → c185
EQT(resource, tuplenil(z0)) → c186
EQT(tag, nil) → c187
EQT(tag, a) → c188
EQT(tag, excl) → c189
EQT(tag, false) → c190
EQT(tag, lock) → c191
EQT(tag, locker) → c192
EQT(tag, mcrlrecord) → c193
EQT(tag, ok) → c194
EQT(tag, pending) → c195
EQT(tag, release) → c196
EQT(tag, request) → c197
EQT(tag, resource) → c198
EQT(tag, tag) → c199
EQT(tag, true) → c200
EQT(tag, undefined) → c201
EQT(tag, pid(z0)) → c202
EQT(tag, int(z0)) → c203
EQT(tag, cons(z0, z1)) → c204
EQT(tag, tuple(z0, z1)) → c205
EQT(tag, tuplenil(z0)) → c206
EQT(true, nil) → c207
EQT(true, a) → c208
EQT(true, excl) → c209
EQT(true, false) → c210
EQT(true, lock) → c211
EQT(true, locker) → c212
EQT(true, mcrlrecord) → c213
EQT(true, ok) → c214
EQT(true, pending) → c215
EQT(true, release) → c216
EQT(true, request) → c217
EQT(true, resource) → c218
EQT(true, tag) → c219
EQT(true, true) → c220
EQT(true, undefined) → c221
EQT(true, pid(z0)) → c222
EQT(true, int(z0)) → c223
EQT(true, cons(z0, z1)) → c224
EQT(true, tuple(z0, z1)) → c225
EQT(true, tuplenil(z0)) → c226
EQT(undefined, nil) → c227
EQT(undefined, a) → c228
EQT(undefined, tuplenil(z0)) → c229
EQT(pid(z0), nil) → c230
EQT(pid(z0), a) → c231
EQT(pid(z0), excl) → c232
EQT(pid(z0), false) → c233
EQT(pid(z0), lock) → c234
EQT(pid(z0), locker) → c235
EQT(pid(z0), mcrlrecord) → c236
EQT(pid(z0), ok) → c237
EQT(pid(z0), pending) → c238
EQT(pid(z0), release) → c239
EQT(pid(z0), request) → c240
EQT(pid(z0), resource) → c241
EQT(pid(z0), tag) → c242
EQT(pid(z0), true) → c243
EQT(pid(z0), undefined) → c244
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(pid(z0), int(z1)) → c246
EQT(pid(z0), cons(z1, z2)) → c247
EQT(pid(z0), tuple(z1, z2)) → c248
EQT(pid(z0), tuplenil(z1)) → c249
EQT(int(z0), nil) → c250
EQT(int(z0), a) → c251
EQT(int(z0), excl) → c252
EQT(int(z0), false) → c253
EQT(int(z0), lock) → c254
EQT(int(z0), locker) → c255
EQT(int(z0), mcrlrecord) → c256
EQT(int(z0), ok) → c257
EQT(int(z0), pending) → c258
EQT(int(z0), release) → c259
EQT(int(z0), request) → c260
EQT(int(z0), resource) → c261
EQT(int(z0), tag) → c262
EQT(int(z0), true) → c263
EQT(int(z0), undefined) → c264
EQT(cons(z0, z1), resource) → c265
EQT(cons(z0, z1), tag) → c266
EQT(cons(z0, z1), true) → c267
EQT(cons(z0, z1), undefined) → c268
EQT(cons(z0, z1), pid(z2)) → c269
EQT(cons(z0, z1), int(z2)) → c270
EQT(cons(z0, z1), cons(z2, z3)) → c271(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), tuple(z2, z3)) → c272
EQT(cons(z0, z1), tuplenil(z2)) → c273
EQT(tuple(z0, z1), nil) → c274
EQT(tuple(z0, z1), a) → c275
EQT(tuple(z0, z1), excl) → c276
EQT(tuple(z0, z1), false) → c277
EQT(tuple(z0, z1), lock) → c278
EQT(tuple(z0, z1), locker) → c279
EQT(tuple(z0, z1), mcrlrecord) → c280
EQT(tuple(z0, z1), ok) → c281
EQT(tuple(z0, z1), pending) → c282
EQT(tuple(z0, z1), release) → c283
EQT(tuple(z0, z1), request) → c284
EQT(tuple(z0, z1), resource) → c285
EQT(tuple(z0, z1), tag) → c286
EQT(tuple(z0, z1), true) → c287
EQT(tuple(z0, z1), undefined) → c288
EQT(tuple(z0, z1), pid(z2)) → c289
EQT(tuple(z0, z1), int(z2)) → c290
EQT(tuple(z0, z1), cons(z2, z3)) → c291
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuplenil(z2)) → c293
EQT(tuplenil(z0), nil) → c294
EQT(tuplenil(z0), a) → c295
EQT(tuplenil(z0), excl) → c296
EQT(tuplenil(z0), false) → c297
EQT(tuplenil(z0), lock) → c298
EQT(tuplenil(z0), locker) → c299
EQT(tuplenil(z0), mcrlrecord) → c300
EQT(tuplenil(z0), ok) → c301
EQT(tuplenil(z0), pending) → c302
EQT(tuplenil(z0), release) → c303
EQT(tuplenil(z0), request) → c304
EQT(tuplenil(z0), resource) → c305
EQT(tuplenil(z0), tag) → c306
EQT(tuplenil(z0), true) → c307
EQT(tuplenil(z0), undefined) → c308
EQT(tuplenil(z0), pid(z1)) → c309
EQT(tuplenil(z0), int(z1)) → c310
EQT(tuplenil(z0), cons(z1, z2)) → c311
EQT(tuplenil(z0), tuple(z1, z2)) → c312
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(0)), tuplenil(z0)) → c314
ELEMENT(int(s(0)), tuple(z0, z1)) → c315
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
RECORD_NEW(lock) → c317
RECORD_EXTRACT(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → c318
RECORD_UPDATE(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → c319
RECORD_UPDATES(z0, z1, nil) → c320
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4), RECORD_UPDATE(z0, z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(nil, z0) → c322
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_PROMOTE_PENDING(z0, z2), LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(nil, z0, z1) → c324
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_ADD_PENDING(nil, z0, z1) → c326
LOCKER2_PROMOTE_PENDING(z0, z1) → c327(CASE0(z1, z0, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
CASE0(z0, z1, cons(z0, z2)) → c328(RECORD_UPDATES(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil))))
CASE0(z0, z1, z2) → c329
LOCKER2_REMOVE_PENDING(z0, z1) → c330(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_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)), MEMBER(record_extract(z0, lock, resource), z1), RECORD_EXTRACT(z0, lock, resource))
CASE1(z0, z1, z2, true) → c332(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))
CASE1(z0, z1, z2, false) → c333
LOCKER2_RELEASE_LOCK(z0, z1) → c334(CASE2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl))), GEN_MODTAGEQ(z1, record_extract(z0, lock, excl)), RECORD_EXTRACT(z0, lock, excl))
CASE2(z0, z1, true) → c335(RECORD_UPDATES(z1, lock, cons(tuple(excllock, excl), nil)))
CASE4(z0, z1, z2) → c336
LOCKER2_OBTAINABLES(nil, z0) → c337
LOCKER2_OBTAINABLES(cons(z0, z1), z2) → c338(CASE5(z2, z1, z0, member(z2, record_extract(z0, lock, pending))), MEMBER(z2, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
CASE5(z0, z1, z2, true) → c339(LOCKER2_OBTAINABLES(z1, z0))
CASE5(z0, z1, z2, false) → c340(LOCKER2_OBTAINABLES(z1, z0))
LOCKER2_CHECK_AVAILABLE(z0, nil) → c341
LOCKER2_CHECK_AVAILABLE(z0, cons(z1, z2)) → c342(CASE6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource))), RECORD_EXTRACT(z1, lock, resource))
CASE6(z0, z1, z2, true) → c343(RECORD_EXTRACT(z1, lock, excl), RECORD_EXTRACT(z1, lock, pending))
CASE6(z0, z1, z2, false) → c344(LOCKER2_CHECK_AVAILABLE(z2, z0))
LOCKER2_CHECK_AVAILABLES(nil, z0) → c345
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLE(z0, z2), LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_ADDUNIQ(nil, z0) → c347
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
SUBTRACT(z0, nil) → c349
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2), DELETE(z1, z0))
DELETE(z0, nil) → c351
DELETE(z0, cons(z1, z2)) → c352(CASE8(z2, z1, z0, equal(z0, z1)))
CASE8(z0, z1, z2, true) → c353
CASE8(z0, z1, z2, false) → c354(DELETE(z2, z0))
GEN_TAG(z0) → c355
GEN_MODTAGEQ(z0, z1) → c356
MEMBER(z0, nil) → c357
MEMBER(z0, cons(z1, z2)) → c358(CASE9(z2, z1, z0, equal(z0, z1)))
CASE9(z0, z1, z2, true) → c359
CASE9(z0, z1, z2, false) → c360(MEMBER(z2, z0))
EQS(empty, empty) → c361
EQS(empty, stack(z0, z1)) → c362
EQS(stack(z0, z1), empty) → c363
EQS(stack(z0, z1), stack(z2, z3)) → c364(AND(eqt(z0, z2), eqs(z1, z3)), EQT(z0, z2), EQS(z1, z3))
PUSHS(z0, z1) → c365
POPS(stack(z0, z1)) → c366
TOPS(stack(z0, z1)) → c367
ISTOPS(z0, empty) → c368
ISTOPS(z0, stack(z1, z2)) → c369(EQT(z0, z1))
EQC(nocalls, nocalls) → c370
EQC(nocalls, calls(z0, z1, z2)) → c371
EQC(calls(z0, z1, z2), nocalls) → c372
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(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))
PUSH(z0, z1, nocalls) → c374
PUSH(z0, z1, calls(z2, z3, z4)) → c375(PUSH1(z0, z1, z2, z3, z4, eqt(z0, z2)), EQT(z0, z2))
PUSH1(z0, z1, z2, z3, z4, T) → c376(PUSHS(z1, z3))
S tuples:
OR(T, T) → c
OR(F, T) → c1
OR(T, F) → c2
OR(F, F) → c3
AND(T, z0) → c4
AND(z0, T) → c5
AND(F, z0) → c6
AND(z0, F) → c7
IMP(T, z0) → c8
IMP(F, z0) → c9
NOT(T) → c10
NOT(F) → c11
IF(T, z0, z1) → c12
IF(F, z0, z1) → c13
EQ(T, T) → c14
EQ(F, F) → c15
EQ(T, F) → c16
EQ(F, T) → c17
EQT(nil, undefined) → c18
EQT(nil, pid(z0)) → c19
EQT(nil, int(z0)) → c20
EQT(nil, cons(z0, z1)) → c21
EQT(nil, tuple(z0, z1)) → c22
EQT(nil, tuplenil(z0)) → c23
EQT(a, nil) → c24
EQT(a, a) → c25
EQT(a, excl) → c26
EQT(a, false) → c27
EQT(a, lock) → c28
EQT(a, locker) → c29
EQT(a, mcrlrecord) → c30
EQT(a, ok) → c31
EQT(a, pending) → c32
EQT(a, release) → c33
EQT(a, request) → c34
EQT(a, resource) → c35
EQT(a, tag) → c36
EQT(a, true) → c37
EQT(a, undefined) → c38
EQT(a, pid(z0)) → c39
EQT(a, int(z0)) → c40
EQT(a, cons(z0, z1)) → c41
EQT(a, tuple(z0, z1)) → c42
EQT(a, tuplenil(z0)) → c43
EQT(excl, nil) → c44
EQT(excl, a) → c45
EQT(excl, excl) → c46
EQT(excl, false) → c47
EQT(excl, lock) → c48
EQT(excl, locker) → c49
EQT(excl, mcrlrecord) → c50
EQT(excl, ok) → c51
EQT(excl, pending) → c52
EQT(excl, release) → c53
EQT(excl, request) → c54
EQT(excl, resource) → c55
EQT(excl, tag) → c56
EQT(excl, true) → c57
EQT(excl, undefined) → c58
EQT(excl, pid(z0)) → c59
EQT(excl, eqt(false, int(z0))) → c60
EQT(false, cons(z0, z1)) → c61
EQT(false, tuple(z0, z1)) → c62
EQT(false, tuplenil(z0)) → c63
EQT(lock, nil) → c64
EQT(lock, a) → c65
EQT(lock, excl) → c66
EQT(lock, false) → c67
EQT(lock, lock) → c68
EQT(lock, locker) → c69
EQT(lock, mcrlrecord) → c70
EQT(lock, ok) → c71
EQT(lock, pending) → c72
EQT(lock, release) → c73
EQT(lock, request) → c74
EQT(lock, resource) → c75
EQT(lock, tag) → c76
EQT(lock, true) → c77
EQT(lock, undefined) → c78
EQT(lock, pid(z0)) → c79
EQT(lock, int(z0)) → c80
EQT(lock, cons(z0, z1)) → c81
EQT(lock, tuple(z0, z1)) → c82
EQT(lock, tuplenil(z0)) → c83
EQT(locker, nil) → c84
EQT(locker, a) → c85
EQT(locker, excl) → c86
EQT(locker, false) → c87
EQT(locker, lock) → c88
EQT(locker, locker) → c89
EQT(locker, mcrlrecord) → c90
EQT(locker, ok) → c91
EQT(locker, pending) → c92
EQT(locker, release) → c93
EQT(locker, request) → c94
EQT(locker, resource) → c95
EQT(locker, tag) → c96
EQT(locker, true) → c97
EQT(locker, undefined) → c98
EQT(locker, pid(z0)) → c99
EQT(locker, int(z0)) → c100
EQT(locker, cons(z0, z1)) → c101
EQT(locker, tuple(z0, z1)) → c102
EQT(locker, tuplenil(z0)) → c103
EQT(mcrlrecord, nil) → c104
EQT(mcrlrecord, a) → c105
EQT(mcrlrecord, excl) → c106
EQT(mcrlrecord, false) → c107
EQT(mcrlrecord, lock) → c108
EQT(mcrlrecord, locker) → c109
EQT(mcrlrecord, mcrlrecord) → c110
EQT(mcrlrecord, ok) → c111
EQT(mcrlrecord, pending) → c112
EQT(mcrlrecord, release) → c113
EQT(mcrlrecord, request) → c114
EQT(mcrlrecord, resource) → c115
EQT(ok, resource) → c116
EQT(ok, tag) → c117
EQT(ok, true) → c118
EQT(ok, undefined) → c119
EQT(ok, pid(z0)) → c120
EQT(ok, int(z0)) → c121
EQT(ok, cons(z0, z1)) → c122
EQT(ok, tuple(z0, z1)) → c123
EQT(ok, tuplenil(z0)) → c124
EQT(pending, nil) → c125
EQT(pending, a) → c126
EQT(pending, excl) → c127
EQT(pending, false) → c128
EQT(pending, lock) → c129
EQT(pending, locker) → c130
EQT(pending, mcrlrecord) → c131
EQT(pending, ok) → c132
EQT(pending, pending) → c133
EQT(pending, release) → c134
EQT(pending, request) → c135
EQT(pending, resource) → c136
EQT(pending, tag) → c137
EQT(pending, true) → c138
EQT(pending, undefined) → c139
EQT(pending, pid(z0)) → c140
EQT(pending, int(z0)) → c141
EQT(pending, cons(z0, z1)) → c142
EQT(pending, tuple(z0, z1)) → c143
EQT(pending, tuplenil(z0)) → c144
EQT(release, nil) → c145
EQT(release, a) → c146
EQT(release, excl) → c147
EQT(release, false) → c148
EQT(release, lock) → c149
EQT(release, locker) → c150
EQT(release, mcrlrecord) → c151
EQT(release, ok) → c152
EQT(request, mcrlrecord) → c153
EQT(request, ok) → c154
EQT(request, pending) → c155
EQT(request, release) → c156
EQT(request, request) → c157
EQT(request, resource) → c158
EQT(request, tag) → c159
EQT(request, true) → c160
EQT(request, undefined) → c161
EQT(request, pid(z0)) → c162
EQT(request, int(z0)) → c163
EQT(request, cons(z0, z1)) → c164
EQT(request, tuple(z0, z1)) → c165
EQT(request, tuplenil(z0)) → c166
EQT(resource, nil) → c167
EQT(resource, a) → c168
EQT(resource, excl) → c169
EQT(resource, false) → c170
EQT(resource, lock) → c171
EQT(resource, locker) → c172
EQT(resource, mcrlrecord) → c173
EQT(resource, ok) → c174
EQT(resource, pending) → c175
EQT(resource, release) → c176
EQT(resource, request) → c177
EQT(resource, resource) → c178
EQT(resource, tag) → c179
EQT(resource, true) → c180
EQT(resource, undefined) → c181
EQT(resource, pid(z0)) → c182
EQT(resource, int(z0)) → c183
EQT(resource, cons(z0, z1)) → c184
EQT(resource, tuple(z0, z1)) → c185
EQT(resource, tuplenil(z0)) → c186
EQT(tag, nil) → c187
EQT(tag, a) → c188
EQT(tag, excl) → c189
EQT(tag, false) → c190
EQT(tag, lock) → c191
EQT(tag, locker) → c192
EQT(tag, mcrlrecord) → c193
EQT(tag, ok) → c194
EQT(tag, pending) → c195
EQT(tag, release) → c196
EQT(tag, request) → c197
EQT(tag, resource) → c198
EQT(tag, tag) → c199
EQT(tag, true) → c200
EQT(tag, undefined) → c201
EQT(tag, pid(z0)) → c202
EQT(tag, int(z0)) → c203
EQT(tag, cons(z0, z1)) → c204
EQT(tag, tuple(z0, z1)) → c205
EQT(tag, tuplenil(z0)) → c206
EQT(true, nil) → c207
EQT(true, a) → c208
EQT(true, excl) → c209
EQT(true, false) → c210
EQT(true, lock) → c211
EQT(true, locker) → c212
EQT(true, mcrlrecord) → c213
EQT(true, ok) → c214
EQT(true, pending) → c215
EQT(true, release) → c216
EQT(true, request) → c217
EQT(true, resource) → c218
EQT(true, tag) → c219
EQT(true, true) → c220
EQT(true, undefined) → c221
EQT(true, pid(z0)) → c222
EQT(true, int(z0)) → c223
EQT(true, cons(z0, z1)) → c224
EQT(true, tuple(z0, z1)) → c225
EQT(true, tuplenil(z0)) → c226
EQT(undefined, nil) → c227
EQT(undefined, a) → c228
EQT(undefined, tuplenil(z0)) → c229
EQT(pid(z0), nil) → c230
EQT(pid(z0), a) → c231
EQT(pid(z0), excl) → c232
EQT(pid(z0), false) → c233
EQT(pid(z0), lock) → c234
EQT(pid(z0), locker) → c235
EQT(pid(z0), mcrlrecord) → c236
EQT(pid(z0), ok) → c237
EQT(pid(z0), pending) → c238
EQT(pid(z0), release) → c239
EQT(pid(z0), request) → c240
EQT(pid(z0), resource) → c241
EQT(pid(z0), tag) → c242
EQT(pid(z0), true) → c243
EQT(pid(z0), undefined) → c244
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(pid(z0), int(z1)) → c246
EQT(pid(z0), cons(z1, z2)) → c247
EQT(pid(z0), tuple(z1, z2)) → c248
EQT(pid(z0), tuplenil(z1)) → c249
EQT(int(z0), nil) → c250
EQT(int(z0), a) → c251
EQT(int(z0), excl) → c252
EQT(int(z0), false) → c253
EQT(int(z0), lock) → c254
EQT(int(z0), locker) → c255
EQT(int(z0), mcrlrecord) → c256
EQT(int(z0), ok) → c257
EQT(int(z0), pending) → c258
EQT(int(z0), release) → c259
EQT(int(z0), request) → c260
EQT(int(z0), resource) → c261
EQT(int(z0), tag) → c262
EQT(int(z0), true) → c263
EQT(int(z0), undefined) → c264
EQT(cons(z0, z1), resource) → c265
EQT(cons(z0, z1), tag) → c266
EQT(cons(z0, z1), true) → c267
EQT(cons(z0, z1), undefined) → c268
EQT(cons(z0, z1), pid(z2)) → c269
EQT(cons(z0, z1), int(z2)) → c270
EQT(cons(z0, z1), cons(z2, z3)) → c271(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(cons(z0, z1), tuple(z2, z3)) → c272
EQT(cons(z0, z1), tuplenil(z2)) → c273
EQT(tuple(z0, z1), nil) → c274
EQT(tuple(z0, z1), a) → c275
EQT(tuple(z0, z1), excl) → c276
EQT(tuple(z0, z1), false) → c277
EQT(tuple(z0, z1), lock) → c278
EQT(tuple(z0, z1), locker) → c279
EQT(tuple(z0, z1), mcrlrecord) → c280
EQT(tuple(z0, z1), ok) → c281
EQT(tuple(z0, z1), pending) → c282
EQT(tuple(z0, z1), release) → c283
EQT(tuple(z0, z1), request) → c284
EQT(tuple(z0, z1), resource) → c285
EQT(tuple(z0, z1), tag) → c286
EQT(tuple(z0, z1), true) → c287
EQT(tuple(z0, z1), undefined) → c288
EQT(tuple(z0, z1), pid(z2)) → c289
EQT(tuple(z0, z1), int(z2)) → c290
EQT(tuple(z0, z1), cons(z2, z3)) → c291
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuplenil(z2)) → c293
EQT(tuplenil(z0), nil) → c294
EQT(tuplenil(z0), a) → c295
EQT(tuplenil(z0), excl) → c296
EQT(tuplenil(z0), false) → c297
EQT(tuplenil(z0), lock) → c298
EQT(tuplenil(z0), locker) → c299
EQT(tuplenil(z0), mcrlrecord) → c300
EQT(tuplenil(z0), ok) → c301
EQT(tuplenil(z0), pending) → c302
EQT(tuplenil(z0), release) → c303
EQT(tuplenil(z0), request) → c304
EQT(tuplenil(z0), resource) → c305
EQT(tuplenil(z0), tag) → c306
EQT(tuplenil(z0), true) → c307
EQT(tuplenil(z0), undefined) → c308
EQT(tuplenil(z0), pid(z1)) → c309
EQT(tuplenil(z0), int(z1)) → c310
EQT(tuplenil(z0), cons(z1, z2)) → c311
EQT(tuplenil(z0), tuple(z1, z2)) → c312
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(0)), tuplenil(z0)) → c314
ELEMENT(int(s(0)), tuple(z0, z1)) → c315
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
RECORD_NEW(lock) → c317
RECORD_EXTRACT(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → c318
RECORD_UPDATE(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → c319
RECORD_UPDATES(z0, z1, nil) → c320
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4), RECORD_UPDATE(z0, z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(nil, z0) → c322
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_PROMOTE_PENDING(z0, z2), LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(nil, z0, z1) → c324
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_MAP_ADD_PENDING(nil, z0, z1) → c326
LOCKER2_PROMOTE_PENDING(z0, z1) → c327(CASE0(z1, z0, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
CASE0(z0, z1, cons(z0, z2)) → c328(RECORD_UPDATES(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil))))
CASE0(z0, z1, z2) → c329
LOCKER2_REMOVE_PENDING(z0, z1) → c330(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_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)), MEMBER(record_extract(z0, lock, resource), z1), RECORD_EXTRACT(z0, lock, resource))
CASE1(z0, z1, z2, true) → c332(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))
CASE1(z0, z1, z2, false) → c333
LOCKER2_RELEASE_LOCK(z0, z1) → c334(CASE2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl))), GEN_MODTAGEQ(z1, record_extract(z0, lock, excl)), RECORD_EXTRACT(z0, lock, excl))
CASE2(z0, z1, true) → c335(RECORD_UPDATES(z1, lock, cons(tuple(excllock, excl), nil)))
CASE4(z0, z1, z2) → c336
LOCKER2_OBTAINABLES(nil, z0) → c337
LOCKER2_OBTAINABLES(cons(z0, z1), z2) → c338(CASE5(z2, z1, z0, member(z2, record_extract(z0, lock, pending))), MEMBER(z2, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
CASE5(z0, z1, z2, true) → c339(LOCKER2_OBTAINABLES(z1, z0))
CASE5(z0, z1, z2, false) → c340(LOCKER2_OBTAINABLES(z1, z0))
LOCKER2_CHECK_AVAILABLE(z0, nil) → c341
LOCKER2_CHECK_AVAILABLE(z0, cons(z1, z2)) → c342(CASE6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource))), RECORD_EXTRACT(z1, lock, resource))
CASE6(z0, z1, z2, true) → c343(RECORD_EXTRACT(z1, lock, excl), RECORD_EXTRACT(z1, lock, pending))
CASE6(z0, z1, z2, false) → c344(LOCKER2_CHECK_AVAILABLE(z2, z0))
LOCKER2_CHECK_AVAILABLES(nil, z0) → c345
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLE(z0, z2), LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_ADDUNIQ(nil, z0) → c347
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
SUBTRACT(z0, nil) → c349
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2), DELETE(z1, z0))
DELETE(z0, nil) → c351
DELETE(z0, cons(z1, z2)) → c352(CASE8(z2, z1, z0, equal(z0, z1)))
CASE8(z0, z1, z2, true) → c353
CASE8(z0, z1, z2, false) → c354(DELETE(z2, z0))
GEN_TAG(z0) → c355
GEN_MODTAGEQ(z0, z1) → c356
MEMBER(z0, nil) → c357
MEMBER(z0, cons(z1, z2)) → c358(CASE9(z2, z1, z0, equal(z0, z1)))
CASE9(z0, z1, z2, true) → c359
CASE9(z0, z1, z2, false) → c360(MEMBER(z2, z0))
EQS(empty, empty) → c361
EQS(empty, stack(z0, z1)) → c362
EQS(stack(z0, z1), empty) → c363
EQS(stack(z0, z1), stack(z2, z3)) → c364(AND(eqt(z0, z2), eqs(z1, z3)), EQT(z0, z2), EQS(z1, z3))
PUSHS(z0, z1) → c365
POPS(stack(z0, z1)) → c366
TOPS(stack(z0, z1)) → c367
ISTOPS(z0, empty) → c368
ISTOPS(z0, stack(z1, z2)) → c369(EQT(z0, z1))
EQC(nocalls, nocalls) → c370
EQC(nocalls, calls(z0, z1, z2)) → c371
EQC(calls(z0, z1, z2), nocalls) → c372
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(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))
PUSH(z0, z1, nocalls) → c374
PUSH(z0, z1, calls(z2, z3, z4)) → c375(PUSH1(z0, z1, z2, z3, z4, eqt(z0, z2)), EQT(z0, z2))
PUSH1(z0, z1, z2, z3, z4, T) → c376(PUSHS(z1, z3))
K tuples:none
Defined Rule Symbols:
or, and, imp, not, if, eq, eqt, element, record_new, record_extract, record_update, record_updates, locker2_map_promote_pending, locker2_map_claim_lock, locker2_map_add_pending, locker2_promote_pending, case0, locker2_remove_pending, locker2_add_pending, case1, locker2_release_lock, case2, case4, locker2_obtainables, case5, locker2_check_available, case6, locker2_check_availables, locker2_adduniq, append, subtract, delete, case8, gen_tag, gen_modtageq, member, case9, eqs, pushs, pops, tops, istops, eqc, push, push1
Defined Pair Symbols:
OR, AND, IMP, NOT, IF, EQ, EQT, ELEMENT, RECORD_NEW, RECORD_EXTRACT, RECORD_UPDATE, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_MAP_CLAIM_LOCK, LOCKER2_MAP_ADD_PENDING, LOCKER2_PROMOTE_PENDING, CASE0, LOCKER2_REMOVE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_RELEASE_LOCK, CASE2, CASE4, LOCKER2_OBTAINABLES, CASE5, LOCKER2_CHECK_AVAILABLE, CASE6, LOCKER2_CHECK_AVAILABLES, LOCKER2_ADDUNIQ, APPEND, SUBTRACT, DELETE, CASE8, GEN_TAG, GEN_MODTAGEQ, MEMBER, CASE9, EQS, PUSHS, POPS, TOPS, ISTOPS, EQC, PUSH, PUSH1
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, c376
(3) CdtLeafRemovalProof (ComplexityIfPolyImplication transformation)
Removed 2 leading nodes:
ISTOPS(z0, stack(z1, z2)) → c369(EQT(z0, z1))
CASE0(z0, z1, cons(z0, z2)) → c328(RECORD_UPDATES(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil))))
Removed 358 trailing nodes:
EQT(false, tuple(z0, z1)) → c62
SUBTRACT(z0, nil) → c349
EQT(pid(z0), tuple(z1, z2)) → c248
EQT(mcrlrecord, resource) → c115
EQ(T, T) → c14
EQT(a, false) → c27
EQT(locker, cons(z0, z1)) → c101
EQT(locker, mcrlrecord) → c90
EQT(tuplenil(z0), release) → c303
EQT(tuplenil(z0), ok) → c301
EQT(tuple(z0, z1), a) → c275
EQT(mcrlrecord, ok) → c111
EQT(resource, excl) → c169
EQT(release, lock) → c149
EQT(a, tuple(z0, z1)) → c42
EQT(lock, a) → c65
EQT(request, tuple(z0, z1)) → c165
EQT(nil, cons(z0, z1)) → c21
EQT(resource, cons(z0, z1)) → c184
EQT(request, mcrlrecord) → c153
ELEMENT(int(s(0)), tuplenil(z0)) → c314
EQT(ok, true) → c118
EQT(request, tag) → c159
DELETE(z0, cons(z1, z2)) → c352(CASE8(z2, z1, z0, equal(z0, z1)))
EQT(tuplenil(z0), tag) → c306
EQT(pending, nil) → c125
EQT(int(z0), request) → c260
EQT(tag, lock) → c191
EQT(resource, true) → c180
EQT(lock, excl) → c66
EQT(cons(z0, z1), resource) → c265
EQT(tuplenil(z0), resource) → c305
LOCKER2_PROMOTE_PENDING(z0, z1) → c327(CASE0(z1, z0, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
EQT(int(z0), excl) → c252
EQT(a, tag) → c36
EQT(locker, lock) → c88
EQT(cons(z0, z1), tuplenil(z2)) → c273
EQT(tag, request) → c197
EQT(request, pid(z0)) → c162
EQT(tuplenil(z0), nil) → c294
EQT(true, locker) → c212
IMP(F, z0) → c9
EQT(a, nil) → c24
EQT(tuple(z0, z1), false) → c277
IF(F, z0, z1) → c13
EQT(request, undefined) → c161
EQT(ok, undefined) → c119
EQT(tuple(z0, z1), request) → c284
EQT(a, a) → c25
EQT(release, nil) → c145
EQT(release, mcrlrecord) → c151
EQT(a, lock) → c28
EQT(true, undefined) → c221
EQT(locker, resource) → c95
EQT(pending, false) → c128
EQT(locker, true) → c97
EQT(true, request) → c217
EQT(request, request) → c157
EQT(pending, ok) → c132
EQT(request, pending) → c155
EQT(lock, tuplenil(z0)) → c83
EQT(pending, mcrlrecord) → c131
EQT(release, excl) → c147
EQT(tag, pid(z0)) → c202
EQT(a, int(z0)) → c40
EQT(excl, lock) → c48
EQT(locker, undefined) → c98
EQT(pid(z0), tag) → c242
EQT(pid(z0), lock) → c234
EQT(request, release) → c156
EQT(pid(z0), false) → c233
EQT(mcrlrecord, request) → c114
EQT(request, true) → c160
EQT(undefined, nil) → c227
EQT(release, ok) → c152
EQT(locker, release) → c93
EQT(mcrlrecord, mcrlrecord) → c110
EQT(int(z0), tag) → c262
EQT(pid(z0), pending) → c238
EQT(resource, pid(z0)) → c182
EQT(tag, undefined) → c201
EQC(calls(z0, z1, z2), nocalls) → c372
EQT(pid(z0), cons(z1, z2)) → c247
EQT(tag, excl) → c189
EQT(pid(z0), locker) → c235
EQT(a, ok) → c31
EQT(excl, release) → c53
EQT(lock, tuple(z0, z1)) → c82
EQT(pid(z0), int(z1)) → c246
EQS(empty, empty) → c361
EQT(int(z0), pending) → c258
EQT(a, excl) → c26
EQ(T, F) → c16
LOCKER2_ADDUNIQ(nil, z0) → c347
EQS(stack(z0, z1), empty) → c363
EQT(excl, pid(z0)) → c59
EQT(lock, nil) → c64
EQT(resource, mcrlrecord) → c173
EQC(nocalls, calls(z0, z1, z2)) → c371
EQT(pid(z0), mcrlrecord) → c236
LOCKER2_OBTAINABLES(cons(z0, z1), z2) → c338(CASE5(z2, z1, z0, member(z2, record_extract(z0, lock, pending))), MEMBER(z2, record_extract(z0, lock, pending)), RECORD_EXTRACT(z0, lock, pending))
EQT(ok, tag) → c117
EQT(pending, excl) → c127
EQT(pending, tuplenil(z0)) → c144
EQT(resource, locker) → c172
OR(F, F) → c3
CASE0(z0, z1, z2) → c329
EQT(true, cons(z0, z1)) → c224
EQT(release, a) → c146
EQT(request, resource) → c158
EQT(tuple(z0, z1), tuplenil(z2)) → c293
EQT(pending, true) → c138
EQT(pid(z0), undefined) → c244
PUSH1(z0, z1, z2, z3, z4, T) → c376(PUSHS(z1, z3))
CASE9(z0, z1, z2, true) → c359
EQT(pending, tuple(z0, z1)) → c143
EQT(resource, resource) → c178
EQT(resource, pending) → c175
EQT(int(z0), release) → c259
EQT(pending, lock) → c129
EQT(locker, excl) → c86
EQT(a, true) → c37
LOCKER2_RELEASE_LOCK(z0, z1) → c334(CASE2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl))), GEN_MODTAGEQ(z1, record_extract(z0, lock, excl)), RECORD_EXTRACT(z0, lock, excl))
RECORD_UPDATES(z0, z1, nil) → c320
EQT(cons(z0, z1), int(z2)) → c270
CASE2(z0, z1, true) → c335(RECORD_UPDATES(z1, lock, cons(tuple(excllock, excl), nil)))
EQT(mcrlrecord, excl) → c106
EQT(true, mcrlrecord) → c213
EQT(excl, true) → c57
EQT(resource, ok) → c174
EQT(resource, nil) → c167
EQT(resource, false) → c170
EQT(ok, cons(z0, z1)) → c122
EQT(pending, pending) → c133
EQT(tag, ok) → c194
EQT(tuple(z0, z1), cons(z2, z3)) → c291
AND(z0, T) → c5
EQT(cons(z0, z1), tag) → c266
EQT(int(z0), resource) → c261
EQT(tuplenil(z0), tuple(z1, z2)) → c312
EQT(true, true) → c220
EQT(tag, true) → c200
EQT(release, locker) → c150
EQT(lock, lock) → c68
EQ(F, F) → c15
EQT(resource, undefined) → c181
ISTOPS(z0, empty) → c368
EQT(tuplenil(z0), false) → c297
RECORD_EXTRACT(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → c318
EQT(tag, int(z0)) → c203
EQT(int(z0), false) → c253
EQT(tag, tuple(z0, z1)) → c205
EQT(lock, locker) → c69
EQT(tuple(z0, z1), resource) → c285
CASE5(z0, z1, z2, true) → c339(LOCKER2_OBTAINABLES(z1, z0))
EQT(true, pending) → c215
EQT(pending, locker) → c130
EQT(tuple(z0, z1), excl) → c276
OR(T, T) → c
EQT(nil, tuplenil(z0)) → c23
EQT(pid(z0), nil) → c230
EQ(F, T) → c17
EQT(tag, locker) → c192
EQT(resource, tag) → c179
EQT(lock, release) → c73
EQT(true, lock) → c211
EQT(a, cons(z0, z1)) → c41
EQT(int(z0), true) → c263
AND(z0, F) → c7
EQT(a, pending) → c32
EQT(tuple(z0, z1), pid(z2)) → c289
EQT(true, false) → c210
EQT(true, tag) → c219
EQT(locker, locker) → c89
EQT(locker, pending) → c92
EQT(a, locker) → c29
EQT(lock, true) → c77
DELETE(z0, nil) → c351
EQT(locker, tag) → c96
EQT(pid(z0), tuplenil(z1)) → c249
EQT(mcrlrecord, locker) → c109
EQT(pid(z0), release) → c239
EQT(lock, tag) → c76
EQT(locker, false) → c87
EQT(pending, undefined) → c139
EQT(tuplenil(z0), cons(z1, z2)) → c311
EQT(tuplenil(z0), int(z1)) → c310
EQT(lock, resource) → c75
EQT(ok, tuplenil(z0)) → c124
EQT(excl, tag) → c56
EQT(request, int(z0)) → c163
EQT(tag, mcrlrecord) → c193
ELEMENT(int(s(0)), tuple(z0, z1)) → c315
EQT(tag, pending) → c195
EQT(tag, release) → c196
EQT(excl, false) → c47
CASE8(z0, z1, z2, false) → c354(DELETE(z2, z0))
EQT(locker, pid(z0)) → c99
EQT(excl, mcrlrecord) → c50
CASE8(z0, z1, z2, true) → c353
EQT(tag, a) → c188
EQT(cons(z0, z1), undefined) → c268
EQT(locker, request) → c94
EQT(pid(z0), request) → c240
EQT(a, undefined) → c38
CASE6(z0, z1, z2, true) → c343(RECORD_EXTRACT(z1, lock, excl), RECORD_EXTRACT(z1, lock, pending))
EQT(tuple(z0, z1), undefined) → c288
EQT(pending, tag) → c137
CASE5(z0, z1, z2, false) → c340(LOCKER2_OBTAINABLES(z1, z0))
EQT(tuple(z0, z1), lock) → c278
EQT(cons(z0, z1), tuple(z2, z3)) → c272
EQT(excl, request) → c54
EQT(locker, a) → c85
EQT(true, tuplenil(z0)) → c226
EQT(nil, pid(z0)) → c19
EQT(pid(z0), resource) → c241
EQT(excl, a) → c45
EQT(true, release) → c216
EQT(ok, int(z0)) → c121
AND(T, z0) → c4
EQT(lock, ok) → c71
EQT(locker, nil) → c84
IMP(T, z0) → c8
IF(T, z0, z1) → c12
EQT(nil, undefined) → c18
EQT(tuple(z0, z1), locker) → c279
EQT(true, resource) → c218
LOCKER2_MAP_PROMOTE_PENDING(nil, z0) → c322
EQT(a, pid(z0)) → c39
LOCKER2_OBTAINABLES(nil, z0) → c337
EQT(release, false) → c148
CASE1(z0, z1, z2, false) → c333
EQT(cons(z0, z1), true) → c267
EQT(int(z0), a) → c251
NOT(T) → c10
EQT(lock, pid(z0)) → c79
EQT(lock, false) → c67
EQT(excl, ok) → c51
EQT(tuple(z0, z1), int(z2)) → c290
CASE4(z0, z1, z2) → c336
EQT(excl, resource) → c55
EQT(lock, pending) → c72
EQT(locker, ok) → c91
EQT(int(z0), mcrlrecord) → c256
EQT(excl, excl) → c46
EQT(tuplenil(z0), locker) → c299
MEMBER(z0, cons(z1, z2)) → c358(CASE9(z2, z1, z0, equal(z0, z1)))
EQT(tuplenil(z0), lock) → c298
EQT(resource, release) → c176
EQT(tuplenil(z0), excl) → c296
GEN_MODTAGEQ(z0, z1) → c356
GEN_TAG(z0) → c355
EQT(true, excl) → c209
EQT(tag, tuplenil(z0)) → c206
EQT(pending, release) → c134
EQT(int(z0), ok) → c257
EQT(a, mcrlrecord) → c30
EQT(undefined, a) → c228
EQT(a, release) → c33
EQT(tuplenil(z0), true) → c307
EQT(mcrlrecord, release) → c113
EQT(lock, request) → c74
EQT(tuple(z0, z1), ok) → c281
EQT(a, request) → c34
MEMBER(z0, nil) → c357
EQT(excl, eqt(false, int(z0))) → c60
EQT(excl, nil) → c44
EQT(tuple(z0, z1), mcrlrecord) → c280
LOCKER2_CHECK_AVAILABLE(z0, cons(z1, z2)) → c342(CASE6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource))), RECORD_EXTRACT(z1, lock, resource))
EQT(true, pid(z0)) → c222
EQT(resource, tuple(z0, z1)) → c185
EQT(int(z0), nil) → c250
EQT(resource, lock) → c171
EQT(pending, int(z0)) → c141
EQT(tag, false) → c190
EQT(mcrlrecord, false) → c107
EQT(pending, cons(z0, z1)) → c142
LOCKER2_MAP_ADD_PENDING(nil, z0, z1) → c326
EQT(tag, nil) → c187
EQT(lock, undefined) → c78
EQT(resource, int(z0)) → c183
EQT(request, ok) → c154
PUSH(z0, z1, nocalls) → c374
EQT(mcrlrecord, nil) → c104
EQT(lock, int(z0)) → c80
EQT(ok, pid(z0)) → c120
EQT(pending, request) → c135
EQT(tuplenil(z0), mcrlrecord) → c300
CASE9(z0, z1, z2, false) → c360(MEMBER(z2, z0))
EQT(pid(z0), true) → c243
LOCKER2_MAP_CLAIM_LOCK(nil, z0, z1) → c324
EQT(tag, resource) → c198
RECORD_UPDATE(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → c319
NOT(F) → c11
EQT(tuplenil(z0), request) → c304
AND(F, z0) → c6
RECORD_NEW(lock) → c317
EQT(excl, undefined) → c58
EQT(ok, resource) → c116
EQT(ok, tuple(z0, z1)) → c123
EQT(resource, a) → c168
EQT(mcrlrecord, pending) → c112
EQT(pending, pid(z0)) → c140
EQT(int(z0), locker) → c255
EQT(nil, tuple(z0, z1)) → c22
EQT(tag, tag) → c199
EQT(pid(z0), a) → c231
EQT(request, tuplenil(z0)) → c166
EQT(tag, cons(z0, z1)) → c204
PUSHS(z0, z1) → c365
EQT(a, tuplenil(z0)) → c43
EQT(locker, tuple(z0, z1)) → c102
EQT(excl, pending) → c52
EQT(true, tuple(z0, z1)) → c225
EQT(tuple(z0, z1), release) → c283
EQT(tuplenil(z0), a) → c295
EQT(false, cons(z0, z1)) → c61
EQT(cons(z0, z1), pid(z2)) → c269
EQT(locker, int(z0)) → c100
EQT(tuple(z0, z1), true) → c287
EQT(int(z0), lock) → c254
EQT(int(z0), undefined) → c264
EQT(nil, int(z0)) → c20
CASE6(z0, z1, z2, false) → c344(LOCKER2_CHECK_AVAILABLE(z2, z0))
EQT(tuplenil(z0), undefined) → c308
OR(T, F) → c2
EQT(mcrlrecord, a) → c105
EQT(true, ok) → c214
LOCKER2_CHECK_AVAILABLES(nil, z0) → c345
EQT(locker, tuplenil(z0)) → c103
LOCKER2_CHECK_AVAILABLE(z0, nil) → c341
EQT(undefined, tuplenil(z0)) → c229
EQT(true, nil) → c207
EQT(tuplenil(z0), pending) → c302
TOPS(stack(z0, z1)) → c367
EQT(pid(z0), excl) → c232
POPS(stack(z0, z1)) → c366
EQT(pid(z0), ok) → c237
EQT(resource, tuplenil(z0)) → c186
EQT(false, tuplenil(z0)) → c63
EQT(lock, cons(z0, z1)) → c81
EQT(request, cons(z0, z1)) → c164
EQS(empty, stack(z0, z1)) → c362
EQT(mcrlrecord, lock) → c108
EQT(pending, a) → c126
EQT(true, int(z0)) → c223
EQT(resource, request) → c177
EQC(nocalls, nocalls) → c370
EQT(tuple(z0, z1), pending) → c282
EQT(a, resource) → c35
EQT(pending, resource) → c136
EQT(true, a) → c208
EQT(lock, mcrlrecord) → c70
EQT(tuplenil(z0), pid(z1)) → c309
EQT(excl, locker) → c49
EQT(tuple(z0, z1), nil) → c274
OR(F, T) → c1
EQT(tuple(z0, z1), tag) → c286
(4) Obligation:
Complexity Dependency Tuples Problem
Rules:
or(T, T) → T
or(F, T) → T
or(T, F) → T
or(F, F) → F
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
imp(T, z0) → z0
imp(F, z0) → T
not(T) → F
not(F) → T
if(T, z0, z1) → z0
if(F, z0, z1) → z1
eq(T, T) → T
eq(F, F) → T
eq(T, F) → F
eq(F, T) → F
eqt(nil, undefined) → F
eqt(nil, pid(z0)) → F
eqt(nil, int(z0)) → F
eqt(nil, cons(z0, z1)) → F
eqt(nil, tuple(z0, z1)) → F
eqt(nil, tuplenil(z0)) → 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(z0)) → F
eqt(a, int(z0)) → F
eqt(a, cons(z0, z1)) → F
eqt(a, tuple(z0, z1)) → F
eqt(a, tuplenil(z0)) → 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(z0)) → F
eqt(excl, eqt(false, int(z0))) → F
eqt(false, cons(z0, z1)) → F
eqt(false, tuple(z0, z1)) → F
eqt(false, tuplenil(z0)) → 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(z0)) → F
eqt(lock, int(z0)) → F
eqt(lock, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(lock, tuplenil(z0)) → 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(z0)) → F
eqt(locker, int(z0)) → F
eqt(locker, cons(z0, z1)) → F
eqt(locker, tuple(z0, z1)) → F
eqt(locker, tuplenil(z0)) → 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(z0)) → F
eqt(ok, int(z0)) → F
eqt(ok, cons(z0, z1)) → F
eqt(ok, tuple(z0, z1)) → F
eqt(ok, tuplenil(z0)) → 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(z0)) → F
eqt(pending, int(z0)) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, tuple(z0, z1)) → F
eqt(pending, tuplenil(z0)) → 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(z0)) → F
eqt(request, int(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(request, tuple(z0, z1)) → F
eqt(request, tuplenil(z0)) → 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(z0)) → F
eqt(resource, int(z0)) → F
eqt(resource, cons(z0, z1)) → F
eqt(resource, tuple(z0, z1)) → F
eqt(resource, tuplenil(z0)) → 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(z0)) → F
eqt(tag, int(z0)) → F
eqt(tag, cons(z0, z1)) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tag, tuplenil(z0)) → 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(z0)) → F
eqt(true, int(z0)) → F
eqt(true, cons(z0, z1)) → F
eqt(true, tuple(z0, z1)) → F
eqt(true, tuplenil(z0)) → F
eqt(undefined, nil) → F
eqt(undefined, a) → F
eqt(undefined, tuplenil(z0)) → F
eqt(pid(z0), nil) → F
eqt(pid(z0), a) → F
eqt(pid(z0), excl) → F
eqt(pid(z0), false) → F
eqt(pid(z0), lock) → F
eqt(pid(z0), locker) → F
eqt(pid(z0), mcrlrecord) → F
eqt(pid(z0), ok) → F
eqt(pid(z0), pending) → F
eqt(pid(z0), release) → F
eqt(pid(z0), request) → F
eqt(pid(z0), resource) → F
eqt(pid(z0), tag) → F
eqt(pid(z0), true) → F
eqt(pid(z0), undefined) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(pid(z0), int(z1)) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(int(z0), nil) → F
eqt(int(z0), a) → F
eqt(int(z0), excl) → F
eqt(int(z0), false) → F
eqt(int(z0), lock) → F
eqt(int(z0), locker) → F
eqt(int(z0), mcrlrecord) → F
eqt(int(z0), ok) → F
eqt(int(z0), pending) → F
eqt(int(z0), release) → F
eqt(int(z0), request) → F
eqt(int(z0), resource) → F
eqt(int(z0), tag) → F
eqt(int(z0), true) → F
eqt(int(z0), undefined) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), tag) → F
eqt(cons(z0, z1), true) → F
eqt(cons(z0, z1), undefined) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuple(z0, z1), nil) → F
eqt(tuple(z0, z1), a) → F
eqt(tuple(z0, z1), excl) → F
eqt(tuple(z0, z1), false) → F
eqt(tuple(z0, z1), lock) → F
eqt(tuple(z0, z1), locker) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(tuple(z0, z1), ok) → F
eqt(tuple(z0, z1), pending) → F
eqt(tuple(z0, z1), release) → F
eqt(tuple(z0, z1), request) → F
eqt(tuple(z0, z1), resource) → F
eqt(tuple(z0, z1), tag) → F
eqt(tuple(z0, z1), true) → F
eqt(tuple(z0, z1), undefined) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), nil) → F
eqt(tuplenil(z0), a) → F
eqt(tuplenil(z0), excl) → F
eqt(tuplenil(z0), false) → F
eqt(tuplenil(z0), lock) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(tuplenil(z0), ok) → F
eqt(tuplenil(z0), pending) → F
eqt(tuplenil(z0), release) → F
eqt(tuplenil(z0), request) → F
eqt(tuplenil(z0), resource) → F
eqt(tuplenil(z0), tag) → F
eqt(tuplenil(z0), true) → F
eqt(tuplenil(z0), undefined) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
element(int(s(0)), tuplenil(z0)) → z0
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
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_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
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)
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))
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))
locker2_map_add_pending(nil, z0, z1) → nil
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
case0(z0, z1, z2) → z1
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
case1(z0, z1, z2, false) → z2
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
case4(z0, z1, z2) → false
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
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_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
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_check_availables(nil, z0) → true
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_adduniq(nil, z0) → z0
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
subtract(z0, nil) → z0
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
case8(z0, z1, z2, true) → z0
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
gen_tag(z0) → tuple(z0, tuplenil(tag))
gen_modtageq(z0, z1) → equal(z0, z1)
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
eqs(empty, empty) → T
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
pushs(z0, z1) → stack(z0, z1)
pops(stack(z0, z1)) → z1
tops(stack(z0, z1)) → z0
istops(z0, empty) → F
istops(z0, stack(z1, z2)) → eqt(z0, z1)
eqc(nocalls, nocalls) → T
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c271(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4), RECORD_UPDATE(z0, z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_PROMOTE_PENDING(z0, z2), LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_REMOVE_PENDING(z0, z1) → c330(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_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)), MEMBER(record_extract(z0, lock, resource), z1), RECORD_EXTRACT(z0, lock, resource))
CASE1(z0, z1, z2, true) → c332(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))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLE(z0, z2), LOCKER2_CHECK_AVAILABLES(z1, z2))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2), DELETE(z1, z0))
EQS(stack(z0, z1), stack(z2, z3)) → c364(AND(eqt(z0, z2), eqs(z1, z3)), EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(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))
PUSH(z0, z1, calls(z2, z3, z4)) → c375(PUSH1(z0, z1, z2, z3, z4, eqt(z0, z2)), EQT(z0, z2))
S tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c271(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(AND(eqt(z0, z2), eqt(z1, z3)), EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4), RECORD_UPDATE(z0, z1, z2, z3))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_PROMOTE_PENDING(z0, z2), LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
LOCKER2_REMOVE_PENDING(z0, z1) → c330(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_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)), MEMBER(record_extract(z0, lock, resource), z1), RECORD_EXTRACT(z0, lock, resource))
CASE1(z0, z1, z2, true) → c332(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))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLE(z0, z2), LOCKER2_CHECK_AVAILABLES(z1, z2))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2), DELETE(z1, z0))
EQS(stack(z0, z1), stack(z2, z3)) → c364(AND(eqt(z0, z2), eqs(z1, z3)), EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(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))
PUSH(z0, z1, calls(z2, z3, z4)) → c375(PUSH1(z0, z1, z2, z3, z4, eqt(z0, z2)), EQT(z0, z2))
K tuples:none
Defined Rule Symbols:
or, and, imp, not, if, eq, eqt, element, record_new, record_extract, record_update, record_updates, locker2_map_promote_pending, locker2_map_claim_lock, locker2_map_add_pending, locker2_promote_pending, case0, locker2_remove_pending, locker2_add_pending, case1, locker2_release_lock, case2, case4, locker2_obtainables, case5, locker2_check_available, case6, locker2_check_availables, locker2_adduniq, append, subtract, delete, case8, gen_tag, gen_modtageq, member, case9, eqs, pushs, pops, tops, istops, eqc, push, push1
Defined Pair Symbols:
EQT, ELEMENT, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_MAP_CLAIM_LOCK, LOCKER2_REMOVE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, APPEND, SUBTRACT, EQS, EQC, PUSH
Compound Symbols:
c245, c271, c292, c313, c316, c321, c323, c325, c330, c331, c332, c346, c348, c350, c364, c373, c375
(5) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID) transformation)
Removed 15 trailing tuple parts
(6) Obligation:
Complexity Dependency Tuples Problem
Rules:
or(T, T) → T
or(F, T) → T
or(T, F) → T
or(F, F) → F
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
imp(T, z0) → z0
imp(F, z0) → T
not(T) → F
not(F) → T
if(T, z0, z1) → z0
if(F, z0, z1) → z1
eq(T, T) → T
eq(F, F) → T
eq(T, F) → F
eq(F, T) → F
eqt(nil, undefined) → F
eqt(nil, pid(z0)) → F
eqt(nil, int(z0)) → F
eqt(nil, cons(z0, z1)) → F
eqt(nil, tuple(z0, z1)) → F
eqt(nil, tuplenil(z0)) → 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(z0)) → F
eqt(a, int(z0)) → F
eqt(a, cons(z0, z1)) → F
eqt(a, tuple(z0, z1)) → F
eqt(a, tuplenil(z0)) → 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(z0)) → F
eqt(excl, eqt(false, int(z0))) → F
eqt(false, cons(z0, z1)) → F
eqt(false, tuple(z0, z1)) → F
eqt(false, tuplenil(z0)) → 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(z0)) → F
eqt(lock, int(z0)) → F
eqt(lock, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(lock, tuplenil(z0)) → 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(z0)) → F
eqt(locker, int(z0)) → F
eqt(locker, cons(z0, z1)) → F
eqt(locker, tuple(z0, z1)) → F
eqt(locker, tuplenil(z0)) → 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(z0)) → F
eqt(ok, int(z0)) → F
eqt(ok, cons(z0, z1)) → F
eqt(ok, tuple(z0, z1)) → F
eqt(ok, tuplenil(z0)) → 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(z0)) → F
eqt(pending, int(z0)) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, tuple(z0, z1)) → F
eqt(pending, tuplenil(z0)) → 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(z0)) → F
eqt(request, int(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(request, tuple(z0, z1)) → F
eqt(request, tuplenil(z0)) → 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(z0)) → F
eqt(resource, int(z0)) → F
eqt(resource, cons(z0, z1)) → F
eqt(resource, tuple(z0, z1)) → F
eqt(resource, tuplenil(z0)) → 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(z0)) → F
eqt(tag, int(z0)) → F
eqt(tag, cons(z0, z1)) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tag, tuplenil(z0)) → 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(z0)) → F
eqt(true, int(z0)) → F
eqt(true, cons(z0, z1)) → F
eqt(true, tuple(z0, z1)) → F
eqt(true, tuplenil(z0)) → F
eqt(undefined, nil) → F
eqt(undefined, a) → F
eqt(undefined, tuplenil(z0)) → F
eqt(pid(z0), nil) → F
eqt(pid(z0), a) → F
eqt(pid(z0), excl) → F
eqt(pid(z0), false) → F
eqt(pid(z0), lock) → F
eqt(pid(z0), locker) → F
eqt(pid(z0), mcrlrecord) → F
eqt(pid(z0), ok) → F
eqt(pid(z0), pending) → F
eqt(pid(z0), release) → F
eqt(pid(z0), request) → F
eqt(pid(z0), resource) → F
eqt(pid(z0), tag) → F
eqt(pid(z0), true) → F
eqt(pid(z0), undefined) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(pid(z0), int(z1)) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(int(z0), nil) → F
eqt(int(z0), a) → F
eqt(int(z0), excl) → F
eqt(int(z0), false) → F
eqt(int(z0), lock) → F
eqt(int(z0), locker) → F
eqt(int(z0), mcrlrecord) → F
eqt(int(z0), ok) → F
eqt(int(z0), pending) → F
eqt(int(z0), release) → F
eqt(int(z0), request) → F
eqt(int(z0), resource) → F
eqt(int(z0), tag) → F
eqt(int(z0), true) → F
eqt(int(z0), undefined) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), tag) → F
eqt(cons(z0, z1), true) → F
eqt(cons(z0, z1), undefined) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuple(z0, z1), nil) → F
eqt(tuple(z0, z1), a) → F
eqt(tuple(z0, z1), excl) → F
eqt(tuple(z0, z1), false) → F
eqt(tuple(z0, z1), lock) → F
eqt(tuple(z0, z1), locker) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(tuple(z0, z1), ok) → F
eqt(tuple(z0, z1), pending) → F
eqt(tuple(z0, z1), release) → F
eqt(tuple(z0, z1), request) → F
eqt(tuple(z0, z1), resource) → F
eqt(tuple(z0, z1), tag) → F
eqt(tuple(z0, z1), true) → F
eqt(tuple(z0, z1), undefined) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), nil) → F
eqt(tuplenil(z0), a) → F
eqt(tuplenil(z0), excl) → F
eqt(tuplenil(z0), false) → F
eqt(tuplenil(z0), lock) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(tuplenil(z0), ok) → F
eqt(tuplenil(z0), pending) → F
eqt(tuplenil(z0), release) → F
eqt(tuplenil(z0), request) → F
eqt(tuplenil(z0), resource) → F
eqt(tuplenil(z0), tag) → F
eqt(tuplenil(z0), true) → F
eqt(tuplenil(z0), undefined) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
element(int(s(0)), tuplenil(z0)) → z0
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
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_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
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)
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))
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))
locker2_map_add_pending(nil, z0, z1) → nil
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
case0(z0, z1, z2) → z1
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
case1(z0, z1, z2, false) → z2
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
case4(z0, z1, z2) → false
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
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_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
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_check_availables(nil, z0) → true
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_adduniq(nil, z0) → z0
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
subtract(z0, nil) → z0
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
case8(z0, z1, z2, true) → z0
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
gen_tag(z0) → tuple(z0, tuplenil(tag))
gen_modtageq(z0, z1) → equal(z0, z1)
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
eqs(empty, empty) → T
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
pushs(z0, z1) → stack(z0, z1)
pops(stack(z0, z1)) → z1
tops(stack(z0, z1)) → z0
istops(z0, empty) → F
istops(z0, stack(z1, z2)) → eqt(z0, z1)
eqc(nocalls, nocalls) → T
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_REMOVE_PENDING(z0, z1) → c330(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_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
PUSH(z0, z1, calls(z2, z3, z4)) → c375(EQT(z0, z2))
S tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_REMOVE_PENDING(z0, z1) → c330(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_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
PUSH(z0, z1, calls(z2, z3, z4)) → c375(EQT(z0, z2))
K tuples:none
Defined Rule Symbols:
or, and, imp, not, if, eq, eqt, element, record_new, record_extract, record_update, record_updates, locker2_map_promote_pending, locker2_map_claim_lock, locker2_map_add_pending, locker2_promote_pending, case0, locker2_remove_pending, locker2_add_pending, case1, locker2_release_lock, case2, case4, locker2_obtainables, case5, locker2_check_available, case6, locker2_check_availables, locker2_adduniq, append, subtract, delete, case8, gen_tag, gen_modtageq, member, case9, eqs, pushs, pops, tops, istops, eqc, push, push1
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_REMOVE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, PUSH
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c330, c331, c332, c346, c350, c364, c373, c375
(7) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID) transformation)
Split RHS of tuples not part of any SCC
(8) Obligation:
Complexity Dependency Tuples Problem
Rules:
or(T, T) → T
or(F, T) → T
or(T, F) → T
or(F, F) → F
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
imp(T, z0) → z0
imp(F, z0) → T
not(T) → F
not(F) → T
if(T, z0, z1) → z0
if(F, z0, z1) → z1
eq(T, T) → T
eq(F, F) → T
eq(T, F) → F
eq(F, T) → F
eqt(nil, undefined) → F
eqt(nil, pid(z0)) → F
eqt(nil, int(z0)) → F
eqt(nil, cons(z0, z1)) → F
eqt(nil, tuple(z0, z1)) → F
eqt(nil, tuplenil(z0)) → 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(z0)) → F
eqt(a, int(z0)) → F
eqt(a, cons(z0, z1)) → F
eqt(a, tuple(z0, z1)) → F
eqt(a, tuplenil(z0)) → 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(z0)) → F
eqt(excl, eqt(false, int(z0))) → F
eqt(false, cons(z0, z1)) → F
eqt(false, tuple(z0, z1)) → F
eqt(false, tuplenil(z0)) → 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(z0)) → F
eqt(lock, int(z0)) → F
eqt(lock, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(lock, tuplenil(z0)) → 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(z0)) → F
eqt(locker, int(z0)) → F
eqt(locker, cons(z0, z1)) → F
eqt(locker, tuple(z0, z1)) → F
eqt(locker, tuplenil(z0)) → 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(z0)) → F
eqt(ok, int(z0)) → F
eqt(ok, cons(z0, z1)) → F
eqt(ok, tuple(z0, z1)) → F
eqt(ok, tuplenil(z0)) → 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(z0)) → F
eqt(pending, int(z0)) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, tuple(z0, z1)) → F
eqt(pending, tuplenil(z0)) → 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(z0)) → F
eqt(request, int(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(request, tuple(z0, z1)) → F
eqt(request, tuplenil(z0)) → 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(z0)) → F
eqt(resource, int(z0)) → F
eqt(resource, cons(z0, z1)) → F
eqt(resource, tuple(z0, z1)) → F
eqt(resource, tuplenil(z0)) → 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(z0)) → F
eqt(tag, int(z0)) → F
eqt(tag, cons(z0, z1)) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tag, tuplenil(z0)) → 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(z0)) → F
eqt(true, int(z0)) → F
eqt(true, cons(z0, z1)) → F
eqt(true, tuple(z0, z1)) → F
eqt(true, tuplenil(z0)) → F
eqt(undefined, nil) → F
eqt(undefined, a) → F
eqt(undefined, tuplenil(z0)) → F
eqt(pid(z0), nil) → F
eqt(pid(z0), a) → F
eqt(pid(z0), excl) → F
eqt(pid(z0), false) → F
eqt(pid(z0), lock) → F
eqt(pid(z0), locker) → F
eqt(pid(z0), mcrlrecord) → F
eqt(pid(z0), ok) → F
eqt(pid(z0), pending) → F
eqt(pid(z0), release) → F
eqt(pid(z0), request) → F
eqt(pid(z0), resource) → F
eqt(pid(z0), tag) → F
eqt(pid(z0), true) → F
eqt(pid(z0), undefined) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(pid(z0), int(z1)) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(int(z0), nil) → F
eqt(int(z0), a) → F
eqt(int(z0), excl) → F
eqt(int(z0), false) → F
eqt(int(z0), lock) → F
eqt(int(z0), locker) → F
eqt(int(z0), mcrlrecord) → F
eqt(int(z0), ok) → F
eqt(int(z0), pending) → F
eqt(int(z0), release) → F
eqt(int(z0), request) → F
eqt(int(z0), resource) → F
eqt(int(z0), tag) → F
eqt(int(z0), true) → F
eqt(int(z0), undefined) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), tag) → F
eqt(cons(z0, z1), true) → F
eqt(cons(z0, z1), undefined) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuple(z0, z1), nil) → F
eqt(tuple(z0, z1), a) → F
eqt(tuple(z0, z1), excl) → F
eqt(tuple(z0, z1), false) → F
eqt(tuple(z0, z1), lock) → F
eqt(tuple(z0, z1), locker) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(tuple(z0, z1), ok) → F
eqt(tuple(z0, z1), pending) → F
eqt(tuple(z0, z1), release) → F
eqt(tuple(z0, z1), request) → F
eqt(tuple(z0, z1), resource) → F
eqt(tuple(z0, z1), tag) → F
eqt(tuple(z0, z1), true) → F
eqt(tuple(z0, z1), undefined) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), nil) → F
eqt(tuplenil(z0), a) → F
eqt(tuplenil(z0), excl) → F
eqt(tuplenil(z0), false) → F
eqt(tuplenil(z0), lock) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(tuplenil(z0), ok) → F
eqt(tuplenil(z0), pending) → F
eqt(tuplenil(z0), release) → F
eqt(tuplenil(z0), request) → F
eqt(tuplenil(z0), resource) → F
eqt(tuplenil(z0), tag) → F
eqt(tuplenil(z0), true) → F
eqt(tuplenil(z0), undefined) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
element(int(s(0)), tuplenil(z0)) → z0
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
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_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
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)
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))
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))
locker2_map_add_pending(nil, z0, z1) → nil
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
case0(z0, z1, z2) → z1
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
case1(z0, z1, z2, false) → z2
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
case4(z0, z1, z2) → false
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
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_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
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_check_availables(nil, z0) → true
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_adduniq(nil, z0) → z0
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
subtract(z0, nil) → z0
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
case8(z0, z1, z2, true) → z0
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
gen_tag(z0) → tuple(z0, tuplenil(tag))
gen_modtageq(z0, z1) → equal(z0, z1)
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
eqs(empty, empty) → T
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
pushs(z0, z1) → stack(z0, z1)
pops(stack(z0, z1)) → z1
tops(stack(z0, z1)) → z0
istops(z0, empty) → F
istops(z0, stack(z1, z2)) → eqt(z0, z1)
eqc(nocalls, nocalls) → T
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
PUSH(z0, z1, calls(z2, z3, z4)) → c375(EQT(z0, z2))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
PUSH(z0, z1, calls(z2, z3, z4)) → c375(EQT(z0, z2))
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:
or, and, imp, not, if, eq, eqt, element, record_new, record_extract, record_update, record_updates, locker2_map_promote_pending, locker2_map_claim_lock, locker2_map_add_pending, locker2_promote_pending, case0, locker2_remove_pending, locker2_add_pending, case1, locker2_release_lock, case2, case4, locker2_obtainables, case5, locker2_check_available, case6, locker2_check_availables, locker2_adduniq, append, subtract, delete, case8, gen_tag, gen_modtageq, member, case9, eqs, pushs, pops, tops, istops, eqc, push, push1
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, PUSH, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c375, c
(9) CdtLeafRemovalProof (ComplexityIfPolyImplication transformation)
Removed 1 leading nodes:
PUSH(z0, z1, calls(z2, z3, z4)) → c375(EQT(z0, z2))
(10) Obligation:
Complexity Dependency Tuples Problem
Rules:
or(T, T) → T
or(F, T) → T
or(T, F) → T
or(F, F) → F
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
imp(T, z0) → z0
imp(F, z0) → T
not(T) → F
not(F) → T
if(T, z0, z1) → z0
if(F, z0, z1) → z1
eq(T, T) → T
eq(F, F) → T
eq(T, F) → F
eq(F, T) → F
eqt(nil, undefined) → F
eqt(nil, pid(z0)) → F
eqt(nil, int(z0)) → F
eqt(nil, cons(z0, z1)) → F
eqt(nil, tuple(z0, z1)) → F
eqt(nil, tuplenil(z0)) → 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(z0)) → F
eqt(a, int(z0)) → F
eqt(a, cons(z0, z1)) → F
eqt(a, tuple(z0, z1)) → F
eqt(a, tuplenil(z0)) → 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(z0)) → F
eqt(excl, eqt(false, int(z0))) → F
eqt(false, cons(z0, z1)) → F
eqt(false, tuple(z0, z1)) → F
eqt(false, tuplenil(z0)) → 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(z0)) → F
eqt(lock, int(z0)) → F
eqt(lock, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(lock, tuplenil(z0)) → 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(z0)) → F
eqt(locker, int(z0)) → F
eqt(locker, cons(z0, z1)) → F
eqt(locker, tuple(z0, z1)) → F
eqt(locker, tuplenil(z0)) → 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(z0)) → F
eqt(ok, int(z0)) → F
eqt(ok, cons(z0, z1)) → F
eqt(ok, tuple(z0, z1)) → F
eqt(ok, tuplenil(z0)) → 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(z0)) → F
eqt(pending, int(z0)) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, tuple(z0, z1)) → F
eqt(pending, tuplenil(z0)) → 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(z0)) → F
eqt(request, int(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(request, tuple(z0, z1)) → F
eqt(request, tuplenil(z0)) → 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(z0)) → F
eqt(resource, int(z0)) → F
eqt(resource, cons(z0, z1)) → F
eqt(resource, tuple(z0, z1)) → F
eqt(resource, tuplenil(z0)) → 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(z0)) → F
eqt(tag, int(z0)) → F
eqt(tag, cons(z0, z1)) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tag, tuplenil(z0)) → 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(z0)) → F
eqt(true, int(z0)) → F
eqt(true, cons(z0, z1)) → F
eqt(true, tuple(z0, z1)) → F
eqt(true, tuplenil(z0)) → F
eqt(undefined, nil) → F
eqt(undefined, a) → F
eqt(undefined, tuplenil(z0)) → F
eqt(pid(z0), nil) → F
eqt(pid(z0), a) → F
eqt(pid(z0), excl) → F
eqt(pid(z0), false) → F
eqt(pid(z0), lock) → F
eqt(pid(z0), locker) → F
eqt(pid(z0), mcrlrecord) → F
eqt(pid(z0), ok) → F
eqt(pid(z0), pending) → F
eqt(pid(z0), release) → F
eqt(pid(z0), request) → F
eqt(pid(z0), resource) → F
eqt(pid(z0), tag) → F
eqt(pid(z0), true) → F
eqt(pid(z0), undefined) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(pid(z0), int(z1)) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(int(z0), nil) → F
eqt(int(z0), a) → F
eqt(int(z0), excl) → F
eqt(int(z0), false) → F
eqt(int(z0), lock) → F
eqt(int(z0), locker) → F
eqt(int(z0), mcrlrecord) → F
eqt(int(z0), ok) → F
eqt(int(z0), pending) → F
eqt(int(z0), release) → F
eqt(int(z0), request) → F
eqt(int(z0), resource) → F
eqt(int(z0), tag) → F
eqt(int(z0), true) → F
eqt(int(z0), undefined) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), tag) → F
eqt(cons(z0, z1), true) → F
eqt(cons(z0, z1), undefined) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuple(z0, z1), nil) → F
eqt(tuple(z0, z1), a) → F
eqt(tuple(z0, z1), excl) → F
eqt(tuple(z0, z1), false) → F
eqt(tuple(z0, z1), lock) → F
eqt(tuple(z0, z1), locker) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(tuple(z0, z1), ok) → F
eqt(tuple(z0, z1), pending) → F
eqt(tuple(z0, z1), release) → F
eqt(tuple(z0, z1), request) → F
eqt(tuple(z0, z1), resource) → F
eqt(tuple(z0, z1), tag) → F
eqt(tuple(z0, z1), true) → F
eqt(tuple(z0, z1), undefined) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), nil) → F
eqt(tuplenil(z0), a) → F
eqt(tuplenil(z0), excl) → F
eqt(tuplenil(z0), false) → F
eqt(tuplenil(z0), lock) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(tuplenil(z0), ok) → F
eqt(tuplenil(z0), pending) → F
eqt(tuplenil(z0), release) → F
eqt(tuplenil(z0), request) → F
eqt(tuplenil(z0), resource) → F
eqt(tuplenil(z0), tag) → F
eqt(tuplenil(z0), true) → F
eqt(tuplenil(z0), undefined) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
element(int(s(0)), tuplenil(z0)) → z0
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
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_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
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)
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))
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))
locker2_map_add_pending(nil, z0, z1) → nil
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
case0(z0, z1, z2) → z1
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
case1(z0, z1, z2, false) → z2
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
case4(z0, z1, z2) → false
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
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_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
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_check_availables(nil, z0) → true
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_adduniq(nil, z0) → z0
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
subtract(z0, nil) → z0
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
case8(z0, z1, z2, true) → z0
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
gen_tag(z0) → tuple(z0, tuplenil(tag))
gen_modtageq(z0, z1) → equal(z0, z1)
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
eqs(empty, empty) → T
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
pushs(z0, z1) → stack(z0, z1)
pops(stack(z0, z1)) → z1
tops(stack(z0, z1)) → z0
istops(z0, empty) → F
istops(z0, stack(z1, z2)) → eqt(z0, z1)
eqc(nocalls, nocalls) → T
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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:
or, and, imp, not, if, eq, eqt, element, record_new, record_extract, record_update, record_updates, locker2_map_promote_pending, locker2_map_claim_lock, locker2_map_add_pending, locker2_promote_pending, case0, locker2_remove_pending, locker2_add_pending, case1, locker2_release_lock, case2, case4, locker2_obtainables, case5, locker2_check_available, case6, locker2_check_availables, locker2_adduniq, append, subtract, delete, case8, gen_tag, gen_modtageq, member, case9, eqs, pushs, pops, tops, istops, eqc, push, push1
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(11) 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) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
(12) Obligation:
Complexity Dependency Tuples Problem
Rules:
or(T, T) → T
or(F, T) → T
or(T, F) → T
or(F, F) → F
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
imp(T, z0) → z0
imp(F, z0) → T
not(T) → F
not(F) → T
if(T, z0, z1) → z0
if(F, z0, z1) → z1
eq(T, T) → T
eq(F, F) → T
eq(T, F) → F
eq(F, T) → F
eqt(nil, undefined) → F
eqt(nil, pid(z0)) → F
eqt(nil, int(z0)) → F
eqt(nil, cons(z0, z1)) → F
eqt(nil, tuple(z0, z1)) → F
eqt(nil, tuplenil(z0)) → 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(z0)) → F
eqt(a, int(z0)) → F
eqt(a, cons(z0, z1)) → F
eqt(a, tuple(z0, z1)) → F
eqt(a, tuplenil(z0)) → 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(z0)) → F
eqt(excl, eqt(false, int(z0))) → F
eqt(false, cons(z0, z1)) → F
eqt(false, tuple(z0, z1)) → F
eqt(false, tuplenil(z0)) → 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(z0)) → F
eqt(lock, int(z0)) → F
eqt(lock, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(lock, tuplenil(z0)) → 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(z0)) → F
eqt(locker, int(z0)) → F
eqt(locker, cons(z0, z1)) → F
eqt(locker, tuple(z0, z1)) → F
eqt(locker, tuplenil(z0)) → 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(z0)) → F
eqt(ok, int(z0)) → F
eqt(ok, cons(z0, z1)) → F
eqt(ok, tuple(z0, z1)) → F
eqt(ok, tuplenil(z0)) → 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(z0)) → F
eqt(pending, int(z0)) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, tuple(z0, z1)) → F
eqt(pending, tuplenil(z0)) → 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(z0)) → F
eqt(request, int(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(request, tuple(z0, z1)) → F
eqt(request, tuplenil(z0)) → 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(z0)) → F
eqt(resource, int(z0)) → F
eqt(resource, cons(z0, z1)) → F
eqt(resource, tuple(z0, z1)) → F
eqt(resource, tuplenil(z0)) → 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(z0)) → F
eqt(tag, int(z0)) → F
eqt(tag, cons(z0, z1)) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tag, tuplenil(z0)) → 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(z0)) → F
eqt(true, int(z0)) → F
eqt(true, cons(z0, z1)) → F
eqt(true, tuple(z0, z1)) → F
eqt(true, tuplenil(z0)) → F
eqt(undefined, nil) → F
eqt(undefined, a) → F
eqt(undefined, tuplenil(z0)) → F
eqt(pid(z0), nil) → F
eqt(pid(z0), a) → F
eqt(pid(z0), excl) → F
eqt(pid(z0), false) → F
eqt(pid(z0), lock) → F
eqt(pid(z0), locker) → F
eqt(pid(z0), mcrlrecord) → F
eqt(pid(z0), ok) → F
eqt(pid(z0), pending) → F
eqt(pid(z0), release) → F
eqt(pid(z0), request) → F
eqt(pid(z0), resource) → F
eqt(pid(z0), tag) → F
eqt(pid(z0), true) → F
eqt(pid(z0), undefined) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(pid(z0), int(z1)) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(int(z0), nil) → F
eqt(int(z0), a) → F
eqt(int(z0), excl) → F
eqt(int(z0), false) → F
eqt(int(z0), lock) → F
eqt(int(z0), locker) → F
eqt(int(z0), mcrlrecord) → F
eqt(int(z0), ok) → F
eqt(int(z0), pending) → F
eqt(int(z0), release) → F
eqt(int(z0), request) → F
eqt(int(z0), resource) → F
eqt(int(z0), tag) → F
eqt(int(z0), true) → F
eqt(int(z0), undefined) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), tag) → F
eqt(cons(z0, z1), true) → F
eqt(cons(z0, z1), undefined) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuple(z0, z1), nil) → F
eqt(tuple(z0, z1), a) → F
eqt(tuple(z0, z1), excl) → F
eqt(tuple(z0, z1), false) → F
eqt(tuple(z0, z1), lock) → F
eqt(tuple(z0, z1), locker) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(tuple(z0, z1), ok) → F
eqt(tuple(z0, z1), pending) → F
eqt(tuple(z0, z1), release) → F
eqt(tuple(z0, z1), request) → F
eqt(tuple(z0, z1), resource) → F
eqt(tuple(z0, z1), tag) → F
eqt(tuple(z0, z1), true) → F
eqt(tuple(z0, z1), undefined) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), nil) → F
eqt(tuplenil(z0), a) → F
eqt(tuplenil(z0), excl) → F
eqt(tuplenil(z0), false) → F
eqt(tuplenil(z0), lock) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(tuplenil(z0), ok) → F
eqt(tuplenil(z0), pending) → F
eqt(tuplenil(z0), release) → F
eqt(tuplenil(z0), request) → F
eqt(tuplenil(z0), resource) → F
eqt(tuplenil(z0), tag) → F
eqt(tuplenil(z0), true) → F
eqt(tuplenil(z0), undefined) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
element(int(s(0)), tuplenil(z0)) → z0
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
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_update(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, pending, z3) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z3)))))
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)
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))
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))
locker2_map_add_pending(nil, z0, z1) → nil
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
case0(z0, z1, z2) → z1
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
case1(z0, z1, z2, false) → z2
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
case4(z0, z1, z2) → false
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
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_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
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_check_availables(nil, z0) → true
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_adduniq(nil, z0) → z0
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
subtract(z0, nil) → z0
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
case8(z0, z1, z2, true) → z0
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
gen_tag(z0) → tuple(z0, tuplenil(tag))
gen_modtageq(z0, z1) → equal(z0, z1)
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
eqs(empty, empty) → T
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
pushs(z0, z1) → stack(z0, z1)
pops(stack(z0, z1)) → z1
tops(stack(z0, z1)) → z0
istops(z0, empty) → F
istops(z0, stack(z1, z2)) → eqt(z0, z1)
eqc(nocalls, nocalls) → T
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
Defined Rule Symbols:
or, and, imp, not, if, eq, eqt, element, record_new, record_extract, record_update, record_updates, locker2_map_promote_pending, locker2_map_claim_lock, locker2_map_add_pending, locker2_promote_pending, case0, locker2_remove_pending, locker2_add_pending, case1, locker2_release_lock, case2, case4, locker2_obtainables, case5, locker2_check_available, case6, locker2_check_availables, locker2_adduniq, append, subtract, delete, case8, gen_tag, gen_modtageq, member, case9, eqs, pushs, pops, tops, istops, eqc, push, push1
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(13) CdtUsableRulesProof (EQUIVALENT transformation)
The following rules are not usable and were removed:
or(T, T) → T
or(F, T) → T
or(T, F) → T
or(F, F) → F
and(T, z0) → z0
and(z0, T) → z0
and(F, z0) → F
and(z0, F) → F
imp(T, z0) → z0
imp(F, z0) → T
not(T) → F
not(F) → T
if(T, z0, z1) → z0
if(F, z0, z1) → z1
eq(T, T) → T
eq(F, F) → T
eq(T, F) → F
eq(F, T) → F
eqt(nil, undefined) → F
eqt(nil, pid(z0)) → F
eqt(nil, int(z0)) → F
eqt(nil, cons(z0, z1)) → F
eqt(nil, tuple(z0, z1)) → F
eqt(nil, tuplenil(z0)) → 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(z0)) → F
eqt(a, int(z0)) → F
eqt(a, cons(z0, z1)) → F
eqt(a, tuple(z0, z1)) → F
eqt(a, tuplenil(z0)) → 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(z0)) → F
eqt(excl, eqt(false, int(z0))) → F
eqt(false, cons(z0, z1)) → F
eqt(false, tuple(z0, z1)) → F
eqt(false, tuplenil(z0)) → 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(z0)) → F
eqt(lock, int(z0)) → F
eqt(lock, cons(z0, z1)) → F
eqt(lock, tuple(z0, z1)) → F
eqt(lock, tuplenil(z0)) → 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(z0)) → F
eqt(locker, int(z0)) → F
eqt(locker, cons(z0, z1)) → F
eqt(locker, tuple(z0, z1)) → F
eqt(locker, tuplenil(z0)) → 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(z0)) → F
eqt(ok, int(z0)) → F
eqt(ok, cons(z0, z1)) → F
eqt(ok, tuple(z0, z1)) → F
eqt(ok, tuplenil(z0)) → 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(z0)) → F
eqt(pending, int(z0)) → F
eqt(pending, cons(z0, z1)) → F
eqt(pending, tuple(z0, z1)) → F
eqt(pending, tuplenil(z0)) → 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(z0)) → F
eqt(request, int(z0)) → F
eqt(request, cons(z0, z1)) → F
eqt(request, tuple(z0, z1)) → F
eqt(request, tuplenil(z0)) → 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(z0)) → F
eqt(resource, int(z0)) → F
eqt(resource, cons(z0, z1)) → F
eqt(resource, tuple(z0, z1)) → F
eqt(resource, tuplenil(z0)) → 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(z0)) → F
eqt(tag, int(z0)) → F
eqt(tag, cons(z0, z1)) → F
eqt(tag, tuple(z0, z1)) → F
eqt(tag, tuplenil(z0)) → 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(z0)) → F
eqt(true, int(z0)) → F
eqt(true, cons(z0, z1)) → F
eqt(true, tuple(z0, z1)) → F
eqt(true, tuplenil(z0)) → F
eqt(undefined, nil) → F
eqt(undefined, a) → F
eqt(undefined, tuplenil(z0)) → F
eqt(pid(z0), nil) → F
eqt(pid(z0), a) → F
eqt(pid(z0), excl) → F
eqt(pid(z0), false) → F
eqt(pid(z0), lock) → F
eqt(pid(z0), locker) → F
eqt(pid(z0), mcrlrecord) → F
eqt(pid(z0), ok) → F
eqt(pid(z0), pending) → F
eqt(pid(z0), release) → F
eqt(pid(z0), request) → F
eqt(pid(z0), resource) → F
eqt(pid(z0), tag) → F
eqt(pid(z0), true) → F
eqt(pid(z0), undefined) → F
eqt(pid(z0), pid(z1)) → eqt(z0, z1)
eqt(pid(z0), int(z1)) → F
eqt(pid(z0), cons(z1, z2)) → F
eqt(pid(z0), tuple(z1, z2)) → F
eqt(pid(z0), tuplenil(z1)) → F
eqt(int(z0), nil) → F
eqt(int(z0), a) → F
eqt(int(z0), excl) → F
eqt(int(z0), false) → F
eqt(int(z0), lock) → F
eqt(int(z0), locker) → F
eqt(int(z0), mcrlrecord) → F
eqt(int(z0), ok) → F
eqt(int(z0), pending) → F
eqt(int(z0), release) → F
eqt(int(z0), request) → F
eqt(int(z0), resource) → F
eqt(int(z0), tag) → F
eqt(int(z0), true) → F
eqt(int(z0), undefined) → F
eqt(cons(z0, z1), resource) → F
eqt(cons(z0, z1), tag) → F
eqt(cons(z0, z1), true) → F
eqt(cons(z0, z1), undefined) → F
eqt(cons(z0, z1), pid(z2)) → F
eqt(cons(z0, z1), int(z2)) → F
eqt(cons(z0, z1), cons(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(cons(z0, z1), tuple(z2, z3)) → F
eqt(cons(z0, z1), tuplenil(z2)) → F
eqt(tuple(z0, z1), nil) → F
eqt(tuple(z0, z1), a) → F
eqt(tuple(z0, z1), excl) → F
eqt(tuple(z0, z1), false) → F
eqt(tuple(z0, z1), lock) → F
eqt(tuple(z0, z1), locker) → F
eqt(tuple(z0, z1), mcrlrecord) → F
eqt(tuple(z0, z1), ok) → F
eqt(tuple(z0, z1), pending) → F
eqt(tuple(z0, z1), release) → F
eqt(tuple(z0, z1), request) → F
eqt(tuple(z0, z1), resource) → F
eqt(tuple(z0, z1), tag) → F
eqt(tuple(z0, z1), true) → F
eqt(tuple(z0, z1), undefined) → F
eqt(tuple(z0, z1), pid(z2)) → F
eqt(tuple(z0, z1), int(z2)) → F
eqt(tuple(z0, z1), cons(z2, z3)) → F
eqt(tuple(z0, z1), tuple(z2, z3)) → and(eqt(z0, z2), eqt(z1, z3))
eqt(tuple(z0, z1), tuplenil(z2)) → F
eqt(tuplenil(z0), nil) → F
eqt(tuplenil(z0), a) → F
eqt(tuplenil(z0), excl) → F
eqt(tuplenil(z0), false) → F
eqt(tuplenil(z0), lock) → F
eqt(tuplenil(z0), locker) → F
eqt(tuplenil(z0), mcrlrecord) → F
eqt(tuplenil(z0), ok) → F
eqt(tuplenil(z0), pending) → F
eqt(tuplenil(z0), release) → F
eqt(tuplenil(z0), request) → F
eqt(tuplenil(z0), resource) → F
eqt(tuplenil(z0), tag) → F
eqt(tuplenil(z0), true) → F
eqt(tuplenil(z0), undefined) → F
eqt(tuplenil(z0), pid(z1)) → F
eqt(tuplenil(z0), int(z1)) → F
eqt(tuplenil(z0), cons(z1, z2)) → F
eqt(tuplenil(z0), tuple(z1, z2)) → F
eqt(tuplenil(z0), tuplenil(z1)) → eqt(z0, z1)
element(int(s(0)), tuplenil(z0)) → z0
element(int(s(0)), tuple(z0, z1)) → z0
element(int(s(s(z0))), tuple(z1, z2)) → element(int(s(z0)), z2)
record_new(lock) → tuple(mcrlrecord, tuple(lock, tuple(undefined, tuple(nil, tuplenil(nil)))))
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)
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))
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))
locker2_map_add_pending(nil, z0, z1) → nil
locker2_promote_pending(z0, z1) → case0(z1, z0, record_extract(z0, lock, pending))
case0(z0, z1, cons(z0, z2)) → record_updates(z1, lock, cons(tuple(excl, tuplenil(z0)), cons(tuple(pending, tuplenil(z2)), nil)))
case0(z0, z1, z2) → z1
locker2_remove_pending(z0, z1) → record_updates(z0, lock, cons(tuple(pending, tuplenil(subtract(record_extract(z0, lock, pending), cons(z1, nil)))), nil))
locker2_add_pending(z0, z1, z2) → case1(z2, z1, z0, member(record_extract(z0, lock, resource), z1))
case1(z0, z1, z2, true) → record_updates(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil))
case1(z0, z1, z2, false) → z2
locker2_release_lock(z0, z1) → case2(z1, z0, gen_modtageq(z1, record_extract(z0, lock, excl)))
case2(z0, z1, true) → record_updates(z1, lock, cons(tuple(excllock, excl), nil))
case4(z0, z1, z2) → false
locker2_obtainables(nil, z0) → true
locker2_obtainables(cons(z0, z1), z2) → case5(z2, z1, z0, member(z2, record_extract(z0, lock, pending)))
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_available(z0, nil) → false
locker2_check_available(z0, cons(z1, z2)) → case6(z2, z1, z0, equal(z0, record_extract(z1, lock, resource)))
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_check_availables(nil, z0) → true
locker2_check_availables(cons(z0, z1), z2) → andt(locker2_check_available(z0, z2), locker2_check_availables(z1, z2))
locker2_adduniq(nil, z0) → z0
append(cons(z0, z1), z2) → cons(z0, append(z1, z2))
case8(z0, z1, z2, true) → z0
case8(z0, z1, z2, false) → cons(z1, delete(z2, z0))
gen_tag(z0) → tuple(z0, tuplenil(tag))
gen_modtageq(z0, z1) → equal(z0, z1)
case9(z0, z1, z2, true) → true
case9(z0, z1, z2, false) → member(z2, z0)
eqs(empty, empty) → T
eqs(empty, stack(z0, z1)) → F
eqs(stack(z0, z1), empty) → F
eqs(stack(z0, z1), stack(z2, z3)) → and(eqt(z0, z2), eqs(z1, z3))
pushs(z0, z1) → stack(z0, z1)
pops(stack(z0, z1)) → z1
tops(stack(z0, z1)) → z0
istops(z0, empty) → F
istops(z0, stack(z1, z2)) → eqt(z0, z1)
eqc(nocalls, nocalls) → T
eqc(nocalls, calls(z0, z1, z2)) → F
eqc(calls(z0, z1, z2), nocalls) → F
eqc(calls(z0, z1, z2), calls(z3, z4, z5)) → and(eqt(z0, z3), and(eqs(z1, z4), eqc(z2, z5)))
push(z0, z1, nocalls) → calls(z0, stack(z1, empty), nocalls)
push(z0, z1, calls(z2, z3, z4)) → push1(z0, z1, z2, z3, z4, eqt(z0, z2))
push1(z0, z1, z2, z3, z4, T) → calls(z2, pushs(z1, z3), z4)
(14) 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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(15) CdtRuleRemovalProof (UPPER BOUND (ADD(O(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)) → c316(ELEMENT(int(s(z0)), z2))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = 0
POL(CASE1(x1, x2, x3, x4)) = [4] + [5]x1 + x3
POL(ELEMENT(x1, x2)) = [4]x1
POL(EQC(x1, x2)) = 0
POL(EQS(x1, x2)) = 0
POL(EQT(x1, x2)) = 0
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [4] + [5]x1 + [5]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = 0
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [3] + [3]x1 + [5]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [3] + [5]x2
POL(SUBTRACT(x1, x2)) = 0
POL(append(x1, x2)) = [2]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = 0
POL(case8(x1, x2, x3, x4)) = [3]
POL(case9(x1, x2, x3, x4)) = [2]
POL(cons(x1, x2)) = [4]
POL(delete(x1, x2)) = [4] + [2]x1
POL(equal(x1, x2)) = [2]
POL(false) = [5]
POL(int(x1)) = x1
POL(lock) = 0
POL(mcrlrecord) = [2]
POL(member(x1, x2)) = [2] + [3]x1
POL(nil) = [4]
POL(pending) = [5]
POL(pid(x1)) = [2]
POL(record_extract(x1, x2, x3)) = [3] + [2]x1 + [3]x3
POL(record_update(x1, x2, x3, x4)) = [3] + [3]x1 + [5]x2 + [3]x3 + [2]x4
POL(resource) = 0
POL(s(x1)) = [1] + x1
POL(stack(x1, x2)) = [2]
POL(subtract(x1, x2)) = [5] + [3]x1
POL(true) = [3]
POL(tuple(x1, x2)) = 0
POL(tuplenil(x1)) = [3]
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(17) CdtRuleRemovalProof (UPPER BOUND (ADD(O(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)) → c364(EQT(z0, z2), EQS(z1, z3))
We considered the (Usable) Rules:
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = 0
POL(CASE1(x1, x2, x3, x4)) = [1] + [5]x1 + x2 + [5]x3
POL(ELEMENT(x1, x2)) = [3]x1
POL(EQC(x1, x2)) = [2]x1 + [4]x2
POL(EQS(x1, x2)) = [2]x1 + x2
POL(EQT(x1, x2)) = 0
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [5] + [5]x1 + [3]x2 + [5]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = 0
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [2] + [5]x1 + [4]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [1] + [4]x2
POL(SUBTRACT(x1, x2)) = x1
POL(append(x1, x2)) = [2]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = x1 + x2 + x3
POL(case8(x1, x2, x3, x4)) = 0
POL(case9(x1, x2, x3, x4)) = [2]
POL(cons(x1, x2)) = 0
POL(delete(x1, x2)) = 0
POL(equal(x1, x2)) = [2]
POL(false) = [2]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = [2]
POL(member(x1, x2)) = [2]
POL(nil) = 0
POL(pending) = 0
POL(pid(x1)) = [2]
POL(record_extract(x1, x2, x3)) = [2]x2 + [2]x3
POL(record_update(x1, x2, x3, x4)) = [3] + [2]x1 + [2]x2 + [2]x3 + [3]x4
POL(resource) = [2]
POL(s(x1)) = 0
POL(stack(x1, x2)) = [3] + x1 + x2
POL(subtract(x1, x2)) = [4] + [2]x1 + x2
POL(true) = [3]
POL(tuple(x1, x2)) = [2]
POL(tuplenil(x1)) = [3]
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(19) CdtRuleRemovalProof (UPPER BOUND (ADD(O(n^1))) transformation)
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = 0
POL(CASE1(x1, x2, x3, x4)) = x1 + [2]x2 + x3
POL(ELEMENT(x1, x2)) = 0
POL(EQC(x1, x2)) = [2]x2
POL(EQS(x1, x2)) = [2] + x2
POL(EQT(x1, x2)) = 0
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [3] + x1 + [2]x2 + [4]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = 0
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [2] + [5]x1 + [5]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [5]x2
POL(SUBTRACT(x1, x2)) = [2]
POL(append(x1, x2)) = [2]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = [4] + x1 + x2 + x3
POL(case8(x1, x2, x3, x4)) = [2]
POL(case9(x1, x2, x3, x4)) = [3]
POL(cons(x1, x2)) = 0
POL(delete(x1, x2)) = [2] + x1 + [2]x2
POL(equal(x1, x2)) = [5]
POL(false) = [4]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = [3]
POL(member(x1, x2)) = [3] + [3]x1
POL(nil) = [2]
POL(pending) = 0
POL(pid(x1)) = [2]
POL(record_extract(x1, x2, x3)) = [2] + [2]x1
POL(record_update(x1, x2, x3, x4)) = [2] + [2]x1 + [2]x2 + [3]x3 + [3]x4
POL(resource) = [5]
POL(s(x1)) = 0
POL(stack(x1, x2)) = [1] + x2
POL(subtract(x1, x2)) = [1] + [3]x1 + [5]x2
POL(true) = [5]
POL(tuple(x1, x2)) = [4]
POL(tuplenil(x1)) = [1]
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(21) CdtRuleRemovalProof (UPPER BOUND (ADD(O(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) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
We considered the (Usable) Rules:
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = [4]x1
POL(CASE1(x1, x2, x3, x4)) = [4] + [3]x1 + [3]x2
POL(ELEMENT(x1, x2)) = [4]x1
POL(EQC(x1, x2)) = 0
POL(EQS(x1, x2)) = 0
POL(EQT(x1, x2)) = 0
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [4] + [3]x1 + [4]x2 + [4]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = [2]x1
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [4] + [4]x1 + [5]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [3]x2 + [4]x3
POL(SUBTRACT(x1, x2)) = [1] + x1
POL(append(x1, x2)) = [3]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = [3]
POL(case8(x1, x2, x3, x4)) = 0
POL(case9(x1, x2, x3, x4)) = [2]
POL(cons(x1, x2)) = [1] + x1 + x2
POL(delete(x1, x2)) = 0
POL(equal(x1, x2)) = [3]
POL(false) = [5]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x1, x2)) = [4] + [2]x1 + x2
POL(nil) = 0
POL(pending) = 0
POL(pid(x1)) = [4]
POL(record_extract(x1, x2, x3)) = [2] + [3]x1
POL(record_update(x1, x2, x3, x4)) = [5]x4
POL(resource) = [2]
POL(s(x1)) = 0
POL(stack(x1, x2)) = [3]
POL(subtract(x1, x2)) = [3]
POL(true) = [3]
POL(tuple(x1, x2)) = x1
POL(tuplenil(x1)) = 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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(23) CdtRuleRemovalProof (UPPER BOUND (ADD(O(n^1))) transformation)
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = [2]x1
POL(CASE1(x1, x2, x3, x4)) = [2] + [3]x1 + x3
POL(ELEMENT(x1, x2)) = [5]x1
POL(EQC(x1, x2)) = 0
POL(EQS(x1, x2)) = 0
POL(EQT(x1, x2)) = 0
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [5] + [4]x1 + [5]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = [4]x1
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = [3]x1
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [2] + [3]x1 + [4]x2
POL(RECORD_UPDATES(x1, x2, x3)) = x2 + x3
POL(SUBTRACT(x1, x2)) = [2]
POL(append(x1, x2)) = [5]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = [5]
POL(case8(x1, x2, x3, x4)) = [3]
POL(case9(x1, x2, x3, x4)) = [2]
POL(cons(x1, x2)) = [1] + x2
POL(delete(x1, x2)) = [5]x1 + [2]x2
POL(equal(x1, x2)) = [4]
POL(false) = [2]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x1, x2)) = [1] + [5]x1 + [3]x2
POL(nil) = [1]
POL(pending) = [2]
POL(pid(x1)) = [2]
POL(record_extract(x1, x2, x3)) = [4] + [3]x1 + [2]x2
POL(record_update(x1, x2, x3, x4)) = [3] + [5]x1 + [4]x2 + [3]x4
POL(resource) = [2]
POL(s(x1)) = 0
POL(stack(x1, x2)) = [3]
POL(subtract(x1, x2)) = [5] + [2]x2
POL(true) = [3]
POL(tuple(x1, x2)) = 0
POL(tuplenil(x1)) = [4]
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(25) CdtRuleRemovalProof (UPPER BOUND (ADD(O(n^1))) transformation)
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = [4]x1
POL(CASE1(x1, x2, x3, x4)) = [2]x1 + x2 + x3
POL(ELEMENT(x1, x2)) = 0
POL(EQC(x1, x2)) = 0
POL(EQS(x1, x2)) = 0
POL(EQT(x1, x2)) = 0
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [3] + [4]x1 + [4]x2 + [3]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = [4]x1
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = [4]x1
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = 0
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [4] + [3]x1 + [4]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [3]x2
POL(SUBTRACT(x1, x2)) = [3]
POL(append(x1, x2)) = [5]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = 0
POL(case8(x1, x2, x3, x4)) = [3]
POL(case9(x1, x2, x3, x4)) = [2]
POL(cons(x1, x2)) = [4] + x2
POL(delete(x1, x2)) = [2] + [3]x1
POL(equal(x1, x2)) = [3]
POL(false) = [3]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x1, x2)) = [4]
POL(nil) = [2]
POL(pending) = [3]
POL(pid(x1)) = [3]
POL(record_extract(x1, x2, x3)) = [3] + [2]x1 + x2 + [2]x3
POL(record_update(x1, x2, x3, x4)) = [4] + [3]x1 + [3]x2 + [3]x3
POL(resource) = [2]
POL(s(x1)) = 0
POL(stack(x1, x2)) = [3]
POL(subtract(x1, x2)) = [4] + [4]x1 + x2
POL(true) = [1]
POL(tuple(x1, x2)) = [4]
POL(tuplenil(x1)) = 0
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(27) CdtRuleRemovalProof (UPPER BOUND (ADD(O(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)) → c350(SUBTRACT(delete(z1, z0), z2))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = [4]x1
POL(CASE1(x1, x2, x3, x4)) = [4] + x1 + x2 + x3
POL(ELEMENT(x1, x2)) = [4]x1 + [5]x2
POL(EQC(x1, x2)) = [4]x1 + [4]x2
POL(EQS(x1, x2)) = [2] + [2]x1 + [4]x2
POL(EQT(x1, x2)) = 0
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [4] + [2]x1 + [2]x2 + [3]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = 0
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = [4]x1
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [2] + [3]x1 + [3]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [2] + [3]x2
POL(SUBTRACT(x1, x2)) = x2
POL(append(x1, x2)) = [3]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = [1] + x2 + x3
POL(case8(x1, x2, x3, x4)) = [3]
POL(case9(x1, x2, x3, x4)) = [3]
POL(cons(x1, x2)) = [1] + x1 + x2
POL(delete(x1, x2)) = x1
POL(equal(x1, x2)) = [2]
POL(false) = [3]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = [3]
POL(member(x1, x2)) = [2] + [3]x1
POL(nil) = 0
POL(pending) = [2]
POL(pid(x1)) = [3]
POL(record_extract(x1, x2, x3)) = [3] + [3]x2 + [4]x3
POL(record_update(x1, x2, x3, x4)) = [2] + [3]x1 + [2]x3 + [4]x4
POL(resource) = 0
POL(s(x1)) = 0
POL(stack(x1, x2)) = [2] + x1 + x2
POL(subtract(x1, x2)) = [2] + x1 + [2]x2
POL(true) = [3]
POL(tuple(x1, x2)) = x2
POL(tuplenil(x1)) = [4]
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(29) CdtRuleRemovalProof (UPPER BOUND (ADD(O(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)) → c271(EQT(z0, z2), EQT(z1, z3))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = 0
POL(CASE1(x1, x2, x3, x4)) = [1] + [3]x1 + [3]x2 + [3]x3
POL(ELEMENT(x1, x2)) = [4]x1
POL(EQC(x1, x2)) = [4]x2
POL(EQS(x1, x2)) = [3] + [4]x2
POL(EQT(x1, x2)) = x2
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [1] + [4]x1 + [4]x2 + [5]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = [3]x1
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = [3]x1
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = 0
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [1] + [3]x1 + [3]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [1]
POL(SUBTRACT(x1, x2)) = [1]
POL(append(x1, x2)) = [3]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = [4] + x1 + x2 + x3
POL(case8(x1, x2, x3, x4)) = [2]
POL(case9(x1, x2, x3, x4)) = [2] + x4
POL(cons(x1, x2)) = [1] + x1 + x2
POL(delete(x1, x2)) = [3]x1 + [3]x2
POL(equal(x1, x2)) = [4]
POL(false) = [2]
POL(int(x1)) = 0
POL(lock) = [4]
POL(mcrlrecord) = 0
POL(member(x1, x2)) = [5] + [4]x1 + [3]x2
POL(nil) = 0
POL(pending) = [3]
POL(pid(x1)) = x1
POL(record_extract(x1, x2, x3)) = [3] + [2]x2 + x3
POL(record_update(x1, x2, x3, x4)) = [3]x1 + [2]x2 + [2]x3 + [4]x4
POL(resource) = [3]
POL(s(x1)) = 0
POL(stack(x1, x2)) = x1 + x2
POL(subtract(x1, x2)) = [3] + [4]x1 + [5]x2
POL(true) = [3]
POL(tuple(x1, x2)) = x1 + x2
POL(tuplenil(x1)) = x1
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(31) CdtRuleRemovalProof (UPPER BOUND (ADD(O(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)) → c313(EQT(z0, z1))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = [4]x1
POL(CASE1(x1, x2, x3, x4)) = [3]x1 + [3]x3
POL(ELEMENT(x1, x2)) = [2]x1 + [4]x2
POL(EQC(x1, x2)) = [4]x1 + [5]x2
POL(EQS(x1, x2)) = [2] + x1
POL(EQT(x1, x2)) = x1
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [4]x1 + [3]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = [4]x1
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = 0
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [4]x1 + [4]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [3]x2
POL(SUBTRACT(x1, x2)) = [4]x2
POL(append(x1, x2)) = [3]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = [1] + x1 + x2 + x3
POL(case8(x1, x2, x3, x4)) = [2] + x3
POL(case9(x1, x2, x3, x4)) = x1
POL(cons(x1, x2)) = x1 + x2
POL(delete(x1, x2)) = [4] + [2]x1 + x2
POL(equal(x1, x2)) = [5]
POL(false) = [3]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = [3]
POL(member(x1, x2)) = [4] + x1 + [3]x2
POL(nil) = 0
POL(pending) = [3]
POL(pid(x1)) = x1
POL(record_extract(x1, x2, x3)) = [3] + [3]x2
POL(record_update(x1, x2, x3, x4)) = [2] + [3]x1 + [2]x2
POL(resource) = [5]
POL(s(x1)) = 0
POL(stack(x1, x2)) = x1 + x2
POL(subtract(x1, x2)) = [2]x1 + [4]x2
POL(true) = [5]
POL(tuple(x1, x2)) = x1 + x2
POL(tuplenil(x1)) = [1] + x1
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(33) CdtRuleRemovalProof (UPPER BOUND (ADD(O(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)) → c245(EQT(z0, z1))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = [3]x1
POL(CASE1(x1, x2, x3, x4)) = [3] + x1 + [2]x2 + [2]x3
POL(ELEMENT(x1, x2)) = [4]x1
POL(EQC(x1, x2)) = [4]x1 + [5]x2
POL(EQS(x1, x2)) = [2]x1 + [5]x2
POL(EQT(x1, x2)) = [4]x2
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [3] + [5]x1 + [4]x2 + [3]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = [5]x1
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = 0
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [3] + [5]x1 + [2]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [3] + [2]x2
POL(SUBTRACT(x1, x2)) = [2]x2
POL(append(x1, x2)) = [3]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = x1 + x2 + x3
POL(case8(x1, x2, x3, x4)) = [3]
POL(case9(x1, x2, x3, x4)) = [3]
POL(cons(x1, x2)) = x1 + x2
POL(delete(x1, x2)) = [1] + [3]x1
POL(equal(x1, x2)) = [5]
POL(false) = [2]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x1, x2)) = [2] + [3]x1
POL(nil) = 0
POL(pending) = 0
POL(pid(x1)) = [4] + x1
POL(record_extract(x1, x2, x3)) = [5]x1 + [3]x2 + [2]x3
POL(record_update(x1, x2, x3, x4)) = [4] + [3]x1 + [3]x2 + [2]x3 + [2]x4
POL(resource) = [2]
POL(s(x1)) = 0
POL(stack(x1, x2)) = x1 + x2
POL(subtract(x1, x2)) = [5] + [2]x2
POL(true) = [5]
POL(tuple(x1, x2)) = x1 + x2
POL(tuplenil(x1)) = x1
(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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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)) → c292(EQT(z0, z2), EQT(z1, z3))
K tuples:
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(35) CdtRuleRemovalProof (UPPER BOUND (ADD(O(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)) → c292(EQT(z0, z2), EQT(z1, z3))
We considered the (Usable) Rules:none
And the Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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(x1, x2)) = [4]x1
POL(CASE1(x1, x2, x3, x4)) = [4] + [2]x1 + [2]x3
POL(ELEMENT(x1, x2)) = [3]x1 + [3]x2
POL(EQC(x1, x2)) = [4]x1
POL(EQS(x1, x2)) = [4] + [2]x1
POL(EQT(x1, x2)) = [2]x1
POL(LOCKER2_ADD_PENDING(x1, x2, x3)) = [4] + [2]x1 + [2]x3
POL(LOCKER2_CHECK_AVAILABLES(x1, x2)) = 0
POL(LOCKER2_MAP_CLAIM_LOCK(x1, x2, x3)) = [3]x1
POL(LOCKER2_MAP_PROMOTE_PENDING(x1, x2)) = [2]x1
POL(LOCKER2_REMOVE_PENDING(x1, x2)) = [2] + [3]x1 + [2]x2
POL(RECORD_UPDATES(x1, x2, x3)) = [2] + [2]x2
POL(SUBTRACT(x1, x2)) = [1] + x2
POL(append(x1, x2)) = [5]
POL(c(x1)) = x1
POL(c245(x1)) = x1
POL(c271(x1, x2)) = x1 + x2
POL(c292(x1, x2)) = x1 + x2
POL(c313(x1)) = x1
POL(c316(x1)) = x1
POL(c321(x1)) = x1
POL(c323(x1)) = x1
POL(c325(x1)) = x1
POL(c331(x1)) = x1
POL(c332(x1)) = x1
POL(c346(x1)) = x1
POL(c348(x1)) = x1
POL(c350(x1)) = x1
POL(c364(x1, x2)) = x1 + x2
POL(c373(x1, x2, x3)) = x1 + x2 + x3
POL(calls(x1, x2, x3)) = [2] + x1 + x2 + x3
POL(case8(x1, x2, x3, x4)) = [5]
POL(case9(x1, x2, x3, x4)) = [5]
POL(cons(x1, x2)) = x1 + x2
POL(delete(x1, x2)) = [1] + [5]x1 + [4]x2
POL(equal(x1, x2)) = [2]
POL(false) = [5]
POL(int(x1)) = 0
POL(lock) = 0
POL(mcrlrecord) = 0
POL(member(x1, x2)) = [2] + [2]x1
POL(nil) = 0
POL(pending) = [3]
POL(pid(x1)) = x1
POL(record_extract(x1, x2, x3)) = [2] + [2]x1 + [2]x2 + [2]x3
POL(record_update(x1, x2, x3, x4)) = [3] + [3]x1 + x2 + [2]x3 + [3]x4
POL(resource) = [3]
POL(s(x1)) = 0
POL(stack(x1, x2)) = x1 + x2
POL(subtract(x1, x2)) = [3] + [2]x1 + [5]x2
POL(true) = [2]
POL(tuple(x1, x2)) = [4] + x1 + x2
POL(tuplenil(x1)) = x1
(36) 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)))))
member(z0, nil) → false
member(z0, cons(z1, z2)) → case9(z2, z1, z0, equal(z0, z1))
record_extract(tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2))))), lock, resource) → tuple(mcrlrecord, tuple(lock, tuple(z0, tuple(z1, tuplenil(z2)))))
delete(z0, nil) → nil
delete(z0, cons(z1, z2)) → case8(z2, z1, z0, equal(z0, z1))
subtract(z0, cons(z1, z2)) → subtract(delete(z1, z0), z2)
subtract(z0, nil) → z0
Tuples:
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_ADD_PENDING(z0, z1, z2) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
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) → c331(CASE1(z2, z1, z0, member(record_extract(z0, lock, resource), z1)))
CASE1(z0, z1, z2, true) → c332(RECORD_UPDATES(z2, lock, cons(tuple(pending, tuplenil(append(record_extract(z2, lock, pending), cons(z0, nil)))), nil)))
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)))
ELEMENT(int(s(s(z0))), tuple(z1, z2)) → c316(ELEMENT(int(s(z0)), z2))
EQS(stack(z0, z1), stack(z2, z3)) → c364(EQT(z0, z2), EQS(z1, z3))
EQC(calls(z0, z1, z2), calls(z3, z4, z5)) → c373(EQT(z0, z3), EQS(z1, z4), EQC(z2, z5))
APPEND(cons(z0, z1), z2) → c348(APPEND(z1, z2))
RECORD_UPDATES(z0, z1, cons(tuple(z2, tuplenil(z3)), z4)) → c321(RECORD_UPDATES(record_update(z0, z1, z2, z3), z1, z4))
LOCKER2_MAP_PROMOTE_PENDING(cons(z0, z1), z2) → c323(LOCKER2_MAP_PROMOTE_PENDING(z1, z2))
LOCKER2_CHECK_AVAILABLES(cons(z0, z1), z2) → c346(LOCKER2_CHECK_AVAILABLES(z1, z2))
LOCKER2_MAP_CLAIM_LOCK(cons(z0, z1), z2, z3) → c325(LOCKER2_MAP_CLAIM_LOCK(z1, z2, z3))
SUBTRACT(z0, cons(z1, z2)) → c350(SUBTRACT(delete(z1, z0), z2))
EQT(cons(z0, z1), cons(z2, z3)) → c271(EQT(z0, z2), EQT(z1, z3))
EQT(tuplenil(z0), tuplenil(z1)) → c313(EQT(z0, z1))
EQT(pid(z0), pid(z1)) → c245(EQT(z0, z1))
EQT(tuple(z0, z1), tuple(z2, z3)) → c292(EQT(z0, z2), EQT(z1, z3))
Defined Rule Symbols:
record_update, member, record_extract, delete, subtract
Defined Pair Symbols:
EQT, ELEMENT, LOCKER2_MAP_CLAIM_LOCK, APPEND, RECORD_UPDATES, LOCKER2_MAP_PROMOTE_PENDING, LOCKER2_ADD_PENDING, CASE1, LOCKER2_CHECK_AVAILABLES, SUBTRACT, EQS, EQC, LOCKER2_REMOVE_PENDING
Compound Symbols:
c245, c313, c316, c325, c348, c271, c292, c321, c323, c331, c332, c346, c350, c364, c373, c
(37) SIsEmptyProof (BOTH BOUNDS(ID, ID) transformation)
The set S is empty
(38) BOUNDS(O(1), O(1))