Cairn · module

Cairn.Optimistic.Claims

lean/Cairn/Optimistic/Claims.lean

Optimistic values: the claims

Cairn.Optimistic's claims (cairn^1100–cairn^1114, docs/optimistic.md), stated over a harness machine whose state is the server model's World at keys Nat and boolean values (liked or not), with same equality. Its moves are every way the person, the server and the network act (Cairn.Optimistic.Server): the person flips a key (^1100); the server handles or refuses a packet (^1101, ^1102); the network delivers or loses one, before or after the server handled it (^1103, ^1104); the backoff timer fires (^1105); a view is fetched (^1106). A move's key i picks the i-th packet in the network (nothing if there is none). Any sequence of these is any interleaving of sets and replies, so an invariant of the machine holds after every one.

The invariants:

IdClaimTheorem
^1107a set shows in its own stepTable.shown_set
^1108at most one write in flight per keyWorld.Ok.oneWrite
^1109never more writes than sets, per keyWorld.Ok.writes_le_sets, Table.writes_le_sets
^1110a refusal rolls back in its stepTable.refused_rollback
^1111once settled, a key shows what the server holds, for any order of repliesWorld.Ok.converges
^1112inputs for different keys commuteTable.feed_comm
^1113a settled count is the view's others plus the server's own, never below zeroWorld.Ok.count, count_ge
^1114a view never moves a key written this sessionTable.seen_written

^1107, ^1110, ^1112 and ^1114 hold of every table; the harness states them of the table in every reachable state. The theorems are general (any key type with a lawful order, any value type, any same that is an equivalence); the harness instantiates them. Not imported by Cairn (the host links that); CairnAll imports it, so the ledger reads it.

Imports Cairn.Claims.Core, Cairn.Claims.Elab, Cairn.Optimistic.Server

Order

Claims 15

^1100

Set a value

moveproved
Does

The person flips key k (likes or unlikes it).

Sees

Key k shows the new value in that step, whatever is in flight.

Formal statement
press.post s k s' := s'.table.shown k = !s.table.shown k
proved
1 theorem (sound press), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
not seen
No capture ran.
Proofs
✓ press.press.sound sound press

lean/Cairn/Optimistic/Claims.lean:88 · press · ledger: active

6 generated declarations
def

Cairn.Optimistic.Claims.press.press.apply

lean/Cairn/Optimistic/Claims.lean:88
apply (s : W) (k : Nat) : W

What ^1100 does on press.

def

Cairn.Optimistic.Claims.press.info

lean/Cairn/Optimistic/Claims.lean:88
info : ClaimInfo

The human half of claim ^1100.

theorem

Cairn.Optimistic.Claims.press.preserves

provedlean/Cairn/Optimistic/Claims.lean:88
preserves (P : W → Prop)
  (press : ∀ (s : W) (k : Nat), P s → P (press.apply s k)) : Claims.press.Preserves P

To show every handler of ^1100 keeps a property, show it in the move's own terms.

theorem

Cairn.Optimistic.Claims.press.press.sound

provedlean/Cairn/Optimistic/Claims.lean:88
sound (s : W) (k : Nat) : post s k (apply s k)

^1100 Set a value, on press: whenever the move is enabled, apply meets post.

def

Cairn.Optimistic.Claims.press

lean/Cairn/Optimistic/Claims.lean:88
press : Claims.Move W

^1100 Set a value (move)

Does: The person flips key k (likes or unlikes it).

Sees: Key k shows the new value in that step, whatever is in flight.

def

Cairn.Optimistic.Claims.press.press.post

lean/Cairn/Optimistic/Claims.lean:88
post (s : W) (k : Nat) (s' : W) : Prop

What must follow ^1100 Set a value on press: Key k shows the new value in that step, whatever is in flight.

^1101

The server handles a request

moveproved
Does

The server handles the i-th packet in the network: applies a write (its answer becomes acked) or answers a read with what it holds.

Sees

Nothing changes on screen: the table hears nothing until an answer arrives.

Formal statement
press.post s i s' := s'.table = s.table
proved
1 theorem (sound press), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
not seen
No capture ran.
Proofs
✓ serve.press.sound sound press

lean/Cairn/Optimistic/Claims.lean:96 · serve · ledger: active

6 generated declarations
def

Cairn.Optimistic.Claims.serve.press.apply

lean/Cairn/Optimistic/Claims.lean:96
apply (s : W) (i : Nat) : W

What ^1101 does on press.

theorem

Cairn.Optimistic.Claims.serve.press.sound

provedlean/Cairn/Optimistic/Claims.lean:96
sound (s : W) (i : Nat) : post s i (apply s i)

^1101 The server handles a request, on press: whenever the move is enabled, apply meets post.

theorem

Cairn.Optimistic.Claims.serve.preserves

provedlean/Cairn/Optimistic/Claims.lean:96
preserves (P : W → Prop)
  (press : ∀ (s : W) (i : Nat), P s → P (press.apply s i)) : serve.Preserves P

To show every handler of ^1101 keeps a property, show it in the move's own terms.

def

Cairn.Optimistic.Claims.serve

lean/Cairn/Optimistic/Claims.lean:96
serve : Claims.Move W

^1101 The server handles a request (move)

Does: The server handles the i-th packet in the network: applies a write (its answer becomes acked) or answers a read with what it holds.

Sees: Nothing changes on screen: the table hears nothing until an answer arrives.

def

Cairn.Optimistic.Claims.serve.info

lean/Cairn/Optimistic/Claims.lean:96
info : ClaimInfo

The human half of claim ^1101.

def

Cairn.Optimistic.Claims.serve.press.post

lean/Cairn/Optimistic/Claims.lean:96
post (s : W) (i : Nat) (s' : W) : Prop

What must follow ^1101 The server handles a request on press: Nothing changes on screen: the table hears nothing until an answer arrives.

^1102

The server refuses a request

moveproved
Does

The server refuses the i-th packet in the network, and changes nothing.

Sees

Neither the screen nor the server changes; the refusal is on its way.

Formal statement
press.post s i s' := s'.table = s.table ∧ s'.srv = s.srv
proved
1 theorem (sound press), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
not seen
No capture ran.
Proofs
✓ refuse.press.sound sound press

lean/Cairn/Optimistic/Claims.lean:104 · refuse · ledger: active

6 generated declarations
def

Cairn.Optimistic.Claims.refuse.press.post

lean/Cairn/Optimistic/Claims.lean:104
post (s : W) (i : Nat) (s' : W) : Prop

What must follow ^1102 The server refuses a request on press: Neither the screen nor the server changes; the refusal is on its way.

def

Cairn.Optimistic.Claims.refuse.press.apply

lean/Cairn/Optimistic/Claims.lean:104
apply (s : W) (i : Nat) : W

What ^1102 does on press.

theorem

Cairn.Optimistic.Claims.refuse.preserves

provedlean/Cairn/Optimistic/Claims.lean:104
preserves (P : W → Prop)
  (press : ∀ (s : W) (i : Nat), P s → P (press.apply s i)) : refuse.Preserves P

To show every handler of ^1102 keeps a property, show it in the move's own terms.

def

Cairn.Optimistic.Claims.refuse.info

lean/Cairn/Optimistic/Claims.lean:104
info : ClaimInfo

The human half of claim ^1102.

def

Cairn.Optimistic.Claims.refuse

lean/Cairn/Optimistic/Claims.lean:104
refuse : Claims.Move W

^1102 The server refuses a request (move)

Does: The server refuses the i-th packet in the network, and changes nothing.

Sees: Neither the screen nor the server changes; the refusal is on its way.

theorem

Cairn.Optimistic.Claims.refuse.press.sound

provedlean/Cairn/Optimistic/Claims.lean:104
sound (s : W) (i : Nat) : post s i (apply s i)

^1102 The server refuses a request, on press: whenever the move is enabled, apply meets post.

^1103

An answer arrives

moveproved
Does

The network delivers the i-th packet, an answer or a view, to the table.

Sees

The table settles, rolls back, retries or takes the view; the server is unchanged.

Formal statement
press.post s i s' := s'.srv = s.srv
proved
1 theorem (sound press), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
not seen
No capture ran.
Proofs
✓ deliver.press.sound sound press

lean/Cairn/Optimistic/Claims.lean:115 · deliver · ledger: active

6 generated declarations
def

Cairn.Optimistic.Claims.deliver.press.apply

lean/Cairn/Optimistic/Claims.lean:115
apply (s : W) (i : Nat) : W

What ^1103 does on press.

def

Cairn.Optimistic.Claims.deliver

lean/Cairn/Optimistic/Claims.lean:115
deliver : Claims.Move W

^1103 An answer arrives (move)

Does: The network delivers the i-th packet, an answer or a view, to the table.

Sees: The table settles, rolls back, retries or takes the view; the server is unchanged.

def

Cairn.Optimistic.Claims.deliver.press.post

lean/Cairn/Optimistic/Claims.lean:115
post (s : W) (i : Nat) (s' : W) : Prop

What must follow ^1103 An answer arrives on press: The table settles, rolls back, retries or takes the view; the server is unchanged.

theorem

Cairn.Optimistic.Claims.deliver.preserves

provedlean/Cairn/Optimistic/Claims.lean:115
preserves (P : W → Prop)
  (press : ∀ (s : W) (i : Nat), P s → P (press.apply s i)) : deliver.Preserves P

To show every handler of ^1103 keeps a property, show it in the move's own terms.

def

Cairn.Optimistic.Claims.deliver.info

lean/Cairn/Optimistic/Claims.lean:115
info : ClaimInfo

The human half of claim ^1103.

theorem

Cairn.Optimistic.Claims.deliver.press.sound

provedlean/Cairn/Optimistic/Claims.lean:115
sound (s : W) (i : Nat) : post s i (apply s i)

^1103 An answer arrives, on press: whenever the move is enabled, apply meets post.

^1104

A request or answer is lost

moveproved
Does

The network loses the i-th packet, before or after the server handled it; the table hears lost (a write) or readFailed (a read).

Sees

A lost write puts its key in doubt and sends a read; the server is unchanged.

Formal statement
press.post s i s' := s'.srv = s.srv
proved
1 theorem (sound press), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
not seen
No capture ran.
Proofs
✓ lose.press.sound sound press

lean/Cairn/Optimistic/Claims.lean:123 · lose · ledger: active

6 generated declarations
theorem

Cairn.Optimistic.Claims.lose.preserves

provedlean/Cairn/Optimistic/Claims.lean:123
preserves (P : W → Prop)
  (press : ∀ (s : W) (i : Nat), P s → P (press.apply s i)) : lose.Preserves P

To show every handler of ^1104 keeps a property, show it in the move's own terms.

def

Cairn.Optimistic.Claims.lose.info

lean/Cairn/Optimistic/Claims.lean:123
info : ClaimInfo

The human half of claim ^1104.

theorem

Cairn.Optimistic.Claims.lose.press.sound

provedlean/Cairn/Optimistic/Claims.lean:123
sound (s : W) (i : Nat) : post s i (apply s i)

^1104 A request or answer is lost, on press: whenever the move is enabled, apply meets post.

def

Cairn.Optimistic.Claims.lose

lean/Cairn/Optimistic/Claims.lean:123
lose : Claims.Move W

^1104 A request or answer is lost (move)

Does: The network loses the i-th packet, before or after the server handled it; the table hears lost (a write) or readFailed (a read).

Sees: A lost write puts its key in doubt and sends a read; the server is unchanged.

def

Cairn.Optimistic.Claims.lose.press.apply

lean/Cairn/Optimistic/Claims.lean:123
apply (s : W) (i : Nat) : W

What ^1104 does on press.

def

Cairn.Optimistic.Claims.lose.press.post

lean/Cairn/Optimistic/Claims.lean:123
post (s : W) (i : Nat) (s' : W) : Prop

What must follow ^1104 A request or answer is lost on press: A lost write puts its key in doubt and sends a read; the server is unchanged.

^1105

A retry comes due

moveproved
Does

Key k's backoff timer fires.

Sees

A key waiting after a failed read sends the next read; the server is unchanged.

Formal statement
press.post s k s' := s'.srv = s.srv
proved
1 theorem (sound press), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
not seen
No capture ran.
Proofs
✓ retry.press.sound sound press

lean/Cairn/Optimistic/Claims.lean:131 · retry · ledger: active

6 generated declarations
theorem

Cairn.Optimistic.Claims.retry.press.sound

provedlean/Cairn/Optimistic/Claims.lean:131
sound (s : W) (k : Nat) : post s k (apply s k)

^1105 A retry comes due, on press: whenever the move is enabled, apply meets post.

def

Cairn.Optimistic.Claims.retry

lean/Cairn/Optimistic/Claims.lean:131
retry : Claims.Move W

^1105 A retry comes due (move)

Does: Key k's backoff timer fires.

Sees: A key waiting after a failed read sends the next read; the server is unchanged.

def

Cairn.Optimistic.Claims.retry.info

lean/Cairn/Optimistic/Claims.lean:131
info : ClaimInfo

The human half of claim ^1105.

def

Cairn.Optimistic.Claims.retry.press.post

lean/Cairn/Optimistic/Claims.lean:131
post (s : W) (k : Nat) (s' : W) : Prop

What must follow ^1105 A retry comes due on press: A key waiting after a failed read sends the next read; the server is unchanged.

def

Cairn.Optimistic.Claims.retry.press.apply

lean/Cairn/Optimistic/Claims.lean:131
apply (s : W) (k : Nat) : W

What ^1105 does on press.

theorem

Cairn.Optimistic.Claims.retry.preserves

provedlean/Cairn/Optimistic/Claims.lean:131
preserves (P : W → Prop)
  (press : ∀ (s : W) (k : Nat), P s → P (press.apply s k)) : retry.Preserves P

To show every handler of ^1105 keeps a property, show it in the move's own terms.

^1106

A view is fetched

moveproved
Does

The app fetches a view of key k: what the server holds now, delivered whenever (^1103).

Sees

Nothing changes until the view arrives.

Formal statement
press.post s k s' := s'.table = s.table
proved
1 theorem (sound press), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
not seen
No capture ran.
Proofs
✓ look.press.sound sound press

lean/Cairn/Optimistic/Claims.lean:139 · look · ledger: active

6 generated declarations
def

Cairn.Optimistic.Claims.look.press.post

lean/Cairn/Optimistic/Claims.lean:139
post (s : W) (k : Nat) (s' : W) : Prop

What must follow ^1106 A view is fetched on press: Nothing changes until the view arrives.

def

Cairn.Optimistic.Claims.look.info

lean/Cairn/Optimistic/Claims.lean:139
info : ClaimInfo

The human half of claim ^1106.

theorem

Cairn.Optimistic.Claims.look.press.sound

provedlean/Cairn/Optimistic/Claims.lean:139
sound (s : W) (k : Nat) : post s k (apply s k)

^1106 A view is fetched, on press: whenever the move is enabled, apply meets post.

theorem

Cairn.Optimistic.Claims.look.preserves

provedlean/Cairn/Optimistic/Claims.lean:139
preserves (P : W → Prop)
  (press : ∀ (s : W) (k : Nat), P s → P (press.apply s k)) : look.Preserves P

To show every handler of ^1106 keeps a property, show it in the move's own terms.

def

Cairn.Optimistic.Claims.look.press.apply

lean/Cairn/Optimistic/Claims.lean:139
apply (s : W) (k : Nat) : W

What ^1106 does on press.

def

Cairn.Optimistic.Claims.look

lean/Cairn/Optimistic/Claims.lean:139
look : Claims.Move W

^1106 A view is fetched (move)

Does: The app fetches a view of key k: what the server holds now, delivered whenever (^1103).

Sees: Nothing changes until the view arrives.

^1107

A set shows in its own step

invariantproved
Does

Whatever is in flight or in doubt, setting a key to f of what it shows makes it show exactly that in the same step: what is shown is want, and a set changes want at once.

Formal statement
holds s := ∀ (k : Nat) (f : Bool → Bool),
  (s.table.feed (Input.set k f)).fst.shown k = f (s.table.shown k)
proved
5 theorems (init, step, receive, reachable, reachableAll), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
Proofs
✓ setShows.init init
✓ setShows.step step
✓ setShows.receive receive
✓ setShows.reachable reachable
✓ setShows.reachableAll reachableAll

lean/Cairn/Optimistic/Claims.lean:181 · setShows · ledger: active

8 generated declarations
def

Cairn.Optimistic.Claims.setShows.info

lean/Cairn/Optimistic/Claims.lean:181
info : ClaimInfo

The human half of claim ^1107.

theorem

Cairn.Optimistic.Claims.setShows.receive

provedlean/Cairn/Optimistic/Claims.lean:181
receive (s✝ : Claims.StateOf machine) (m✝ : Msg) :
  holds s✝ → holds (machine.receive s✝ m✝).fst

Every message from the world preserves ^1107.

theorem

Cairn.Optimistic.Claims.setShows.init

provedlean/Cairn/Optimistic/Claims.lean:181
init : holds machine.init

^1107 holds in the initial state.

theorem

Cairn.Optimistic.Claims.setShows.step

provedlean/Cairn/Optimistic/Claims.lean:181
step (s✝ : Claims.StateOf machine) (a✝ : Action) :
  holds s✝ → holds (machine.update s✝ a✝).fst

Every update, so every move, preserves ^1107.

def

Cairn.Optimistic.Claims.setShows.holds

lean/Cairn/Optimistic/Claims.lean:181
holds (s : Claims.StateOf machine) : Prop

^1107 A set shows in its own step: Whatever is in flight or in doubt, setting a key to f of what it shows makes it show exactly that in the same step: what is shown is want, and a set changes want at once.

theorem

Cairn.Optimistic.Claims.setShows.reachableAll

provedlean/Cairn/Optimistic/Claims.lean:181
reachableAll (s✝ : Claims.StateOf machine) :
  machine.ReachableAll s✝ → holds s✝

^1107 holds in every state reachable by actions and messages from the world.

def

Cairn.Optimistic.Claims.setShows

lean/Cairn/Optimistic/Claims.lean:181
setShows : Claims.Invariant machine

^1107 A set shows in its own step (invariant)

Whatever is in flight or in doubt, setting a key to f of what it shows makes it show exactly that in the same step: what is shown is want, and a set changes want at once.

theorem

Cairn.Optimistic.Claims.setShows.reachable

provedlean/Cairn/Optimistic/Claims.lean:181
reachable (s✝ : Claims.StateOf machine) :
  machine.Reachable s✝ → holds s✝

^1107 holds in every reachable state.

^1108

At most one write in flight per key

invariantproved
Does

For every key, at most one write is in the network, before or after the server handled it: a set while one is in flight only changes what is shown.

Formal statement
holds s := Good s ∧ ∀ (k : Nat), List.countP Pkt.isWrite (World.at s.net k) ≤ 1
proved
5 theorems (init, step, receive, reachable, reachableAll), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
Proofs
✓ oneWrite.init init
✓ oneWrite.step step
✓ oneWrite.receive receive
✓ oneWrite.reachable reachable
✓ oneWrite.reachableAll reachableAll

lean/Cairn/Optimistic/Claims.lean:187 · oneWrite · ledger: active

8 generated declarations
theorem

Cairn.Optimistic.Claims.oneWrite.init

provedlean/Cairn/Optimistic/Claims.lean:187
init : holds machine.init

^1108 holds in the initial state.

def

Cairn.Optimistic.Claims.oneWrite

lean/Cairn/Optimistic/Claims.lean:187
oneWrite : Claims.Invariant machine

^1108 At most one write in flight per key (invariant)

For every key, at most one write is in the network, before or after the server handled it: a set while one is in flight only changes what is shown.

theorem

Cairn.Optimistic.Claims.oneWrite.reachable

provedlean/Cairn/Optimistic/Claims.lean:187
reachable (s✝ : Claims.StateOf machine) :
  machine.Reachable s✝ → holds s✝

^1108 holds in every reachable state.

def

Cairn.Optimistic.Claims.oneWrite.info

lean/Cairn/Optimistic/Claims.lean:187
info : ClaimInfo

The human half of claim ^1108.

theorem

Cairn.Optimistic.Claims.oneWrite.reachableAll

provedlean/Cairn/Optimistic/Claims.lean:187
reachableAll (s✝ : Claims.StateOf machine) :
  machine.ReachableAll s✝ → holds s✝

^1108 holds in every state reachable by actions and messages from the world.

def

Cairn.Optimistic.Claims.oneWrite.holds

lean/Cairn/Optimistic/Claims.lean:187
holds (s : Claims.StateOf machine) : Prop

^1108 At most one write in flight per key: For every key, at most one write is in the network, before or after the server handled it: a set while one is in flight only changes what is shown.

theorem

Cairn.Optimistic.Claims.oneWrite.step

provedlean/Cairn/Optimistic/Claims.lean:187
step (s✝ : Claims.StateOf machine) (a✝ : Action) :
  holds s✝ → holds (machine.update s✝ a✝).fst

Every update, so every move, preserves ^1108.

theorem

Cairn.Optimistic.Claims.oneWrite.receive

provedlean/Cairn/Optimistic/Claims.lean:187
receive (s✝ : Claims.StateOf machine) (m✝ : Msg) :
  holds s✝ → holds (machine.receive s✝ m✝).fst

Every message from the world preserves ^1108.

^1109

Never more writes than sets

invariantproved
Does

For every key, the writes the table has sent never outnumber the person's sets of it, whatever answers came back in whatever order: a lost write is read back, never sent again blind.

Formal statement
holds s := Good s ∧ ∀ (k : Nat), List.count k s.writes ≤ List.count k s.sets
proved
5 theorems (init, step, receive, reachable, reachableAll), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
Proofs

lean/Cairn/Optimistic/Claims.lean:193 · writesWithinSets · ledger: active

8 generated declarations
def

Cairn.Optimistic.Claims.writesWithinSets.holds

lean/Cairn/Optimistic/Claims.lean:193
holds (s : Claims.StateOf machine) : Prop

^1109 Never more writes than sets: For every key, the writes the table has sent never outnumber the person's sets of it, whatever answers came back in whatever order: a lost write is read back, never sent again blind.

def

Cairn.Optimistic.Claims.writesWithinSets.info

lean/Cairn/Optimistic/Claims.lean:193
info : ClaimInfo

The human half of claim ^1109.

theorem

Cairn.Optimistic.Claims.writesWithinSets.reachableAll

provedlean/Cairn/Optimistic/Claims.lean:193
reachableAll (s✝ : Claims.StateOf machine) :
  machine.ReachableAll s✝ → holds s✝

^1109 holds in every state reachable by actions and messages from the world.

theorem

Cairn.Optimistic.Claims.writesWithinSets.step

provedlean/Cairn/Optimistic/Claims.lean:193
step (s✝ : Claims.StateOf machine) (a✝ : Action) :
  holds s✝ → holds (machine.update s✝ a✝).fst

Every update, so every move, preserves ^1109.

theorem

Cairn.Optimistic.Claims.writesWithinSets.receive

provedlean/Cairn/Optimistic/Claims.lean:193
receive (s✝ : Claims.StateOf machine) (m✝ : Msg) :
  holds s✝ → holds (machine.receive s✝ m✝).fst

Every message from the world preserves ^1109.

def

Cairn.Optimistic.Claims.writesWithinSets

lean/Cairn/Optimistic/Claims.lean:193
writesWithinSets : Claims.Invariant machine

^1109 Never more writes than sets (invariant)

For every key, the writes the table has sent never outnumber the person's sets of it, whatever answers came back in whatever order: a lost write is read back, never sent again blind.

theorem

Cairn.Optimistic.Claims.writesWithinSets.init

provedlean/Cairn/Optimistic/Claims.lean:193
init : holds machine.init

^1109 holds in the initial state.

theorem

Cairn.Optimistic.Claims.writesWithinSets.reachable

provedlean/Cairn/Optimistic/Claims.lean:193
reachable (s✝ : Claims.StateOf machine) :
  machine.Reachable s✝ → holds s✝

^1109 holds in every reachable state.

^1110

A refusal rolls back in its step

invariantproved
Does

When a key's write in flight is refused, the key shows the server's last confirmed value in that step, that value is unchanged, and nothing is outstanding for the key.

Formal statement
holds s := ∀ (k n : Nat) (why : String) (w : Bool),
  (s.table.get k).phase = Phase.writing w →
    n = (s.table.get k).seq →
      (s.table.feed (Input.refused { key := k, seq := n } why)).fst.shown k =
          s.table.server k ∧
        (s.table.feed (Input.refused { key := k, seq := n } why)).fst.server k =
            s.table.server k ∧
          (s.table.feed (Input.refused { key := k, seq := n } why)).fst.settled k = true
proved
5 theorems (init, step, receive, reachable, reachableAll), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
Proofs

lean/Cairn/Optimistic/Claims.lean:199 · refusalRollsBack · ledger: active

8 generated declarations
def

Cairn.Optimistic.Claims.refusalRollsBack.info

lean/Cairn/Optimistic/Claims.lean:199
info : ClaimInfo

The human half of claim ^1110.

def

Cairn.Optimistic.Claims.refusalRollsBack.holds

lean/Cairn/Optimistic/Claims.lean:199
holds (s : Claims.StateOf machine) : Prop

^1110 A refusal rolls back in its step: When a key's write in flight is refused, the key shows the server's last confirmed value in that step, that value is unchanged, and nothing is outstanding for the key.

theorem

Cairn.Optimistic.Claims.refusalRollsBack.step

provedlean/Cairn/Optimistic/Claims.lean:199
step (s✝ : Claims.StateOf machine) (a✝ : Action) :
  holds s✝ → holds (machine.update s✝ a✝).fst

Every update, so every move, preserves ^1110.

theorem

Cairn.Optimistic.Claims.refusalRollsBack.receive

provedlean/Cairn/Optimistic/Claims.lean:199
receive (s✝ : Claims.StateOf machine) (m✝ : Msg) :
  holds s✝ → holds (machine.receive s✝ m✝).fst

Every message from the world preserves ^1110.

theorem

Cairn.Optimistic.Claims.refusalRollsBack.init

provedlean/Cairn/Optimistic/Claims.lean:199
init : holds machine.init

^1110 holds in the initial state.

theorem

Cairn.Optimistic.Claims.refusalRollsBack.reachableAll

provedlean/Cairn/Optimistic/Claims.lean:199
reachableAll (s✝ : Claims.StateOf machine) :
  machine.ReachableAll s✝ → holds s✝

^1110 holds in every state reachable by actions and messages from the world.

def

Cairn.Optimistic.Claims.refusalRollsBack

lean/Cairn/Optimistic/Claims.lean:199
refusalRollsBack : Claims.Invariant machine

^1110 A refusal rolls back in its step (invariant)

When a key's write in flight is refused, the key shows the server's last confirmed value in that step, that value is unchanged, and nothing is outstanding for the key.

theorem

Cairn.Optimistic.Claims.refusalRollsBack.reachable

provedlean/Cairn/Optimistic/Claims.lean:199
reachable (s✝ : Claims.StateOf machine) :
  machine.Reachable s✝ → holds s✝

^1110 holds in every reachable state.

^1111

Settled keys show what the server holds

invariantproved
Does

Against a server that is a register per key with idempotent writes, for any sequence of sets and any interleaving of replies (each acknowledged, refused, or lost before or after the server applied it, delivered in any order, with views fetched at any time), every key with nothing in flight and nothing in doubt shows what the server holds. So once every reply is in, every key does.

Formal statement
holds s := Good s ∧ ∀ (k : Nat), s.table.settled k = true → s.table.shown k = World.reg s k
proved
5 theorems (init, step, receive, reachable, reachableAll), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
Proofs
✓ converges.receive receive
✓ converges.reachable reachable
✓ converges.reachableAll reachableAll

lean/Cairn/Optimistic/Claims.lean:209 · converges · ledger: active

8 generated declarations
theorem

Cairn.Optimistic.Claims.converges.step

provedlean/Cairn/Optimistic/Claims.lean:209
step (s✝ : Claims.StateOf machine) (a✝ : Action) :
  holds s✝ → holds (machine.update s✝ a✝).fst

Every update, so every move, preserves ^1111.

theorem

Cairn.Optimistic.Claims.converges.receive

provedlean/Cairn/Optimistic/Claims.lean:209
receive (s✝ : Claims.StateOf machine) (m✝ : Msg) :
  holds s✝ → holds (machine.receive s✝ m✝).fst

Every message from the world preserves ^1111.

theorem

Cairn.Optimistic.Claims.converges.init

provedlean/Cairn/Optimistic/Claims.lean:209
init : holds machine.init

^1111 holds in the initial state.

theorem

Cairn.Optimistic.Claims.converges.reachable

provedlean/Cairn/Optimistic/Claims.lean:209
reachable (s✝ : Claims.StateOf machine) :
  machine.Reachable s✝ → holds s✝

^1111 holds in every reachable state.

def

Cairn.Optimistic.Claims.converges.info

lean/Cairn/Optimistic/Claims.lean:209
info : ClaimInfo

The human half of claim ^1111.

theorem

Cairn.Optimistic.Claims.converges.reachableAll

provedlean/Cairn/Optimistic/Claims.lean:209
reachableAll (s✝ : Claims.StateOf machine) :
  machine.ReachableAll s✝ → holds s✝

^1111 holds in every state reachable by actions and messages from the world.

def

Cairn.Optimistic.Claims.converges

lean/Cairn/Optimistic/Claims.lean:209
converges : Claims.Invariant machine

^1111 Settled keys show what the server holds (invariant)

Against a server that is a register per key with idempotent writes, for any sequence of sets and any interleaving of replies (each acknowledged, refused, or lost before or after the server applied it, delivered in any order, with views fetched at any time), every key with nothing in flight and nothing in doubt shows what the server holds. So once every reply is in, every key does.

def

Cairn.Optimistic.Claims.converges.holds

lean/Cairn/Optimistic/Claims.lean:209
holds (s : Claims.StateOf machine) : Prop

^1111 Settled keys show what the server holds: Against a server that is a register per key with idempotent writes, for any sequence of sets and any interleaving of replies (each acknowledged, refused, or lost before or after the server applied it, delivered in any order, with views fetched at any time), every key with nothing in flight and nothing in doubt shows what the server holds. So once every reply is in, every key does.

^1112

Replies for different keys commute

invariantproved
Does

Two inputs about different keys, in either order, leave the table the same at every key, and each gives the outputs it gives alone, so the two orders' outputs are the same two lists swapped.

Formal statement
holds s := ∀ (i j : Input Nat Bool),
  i.key ≠ j.key →
    (∀ (k : Nat),
        ((s.table.feed i).fst.feed j).fst.get k = ((s.table.feed j).fst.feed i).fst.get k) ∧
      ((s.table.feed i).fst.feed j).snd = (s.table.feed j).snd ∧
        ((s.table.feed j).fst.feed i).snd = (s.table.feed i).snd
proved
5 theorems (init, step, receive, reachable, reachableAll), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
Proofs
✓ commute.init init
✓ commute.step step
✓ commute.receive receive
✓ commute.reachable reachable
✓ commute.reachableAll reachableAll

lean/Cairn/Optimistic/Claims.lean:215 · commute · ledger: active

8 generated declarations
def

Cairn.Optimistic.Claims.commute

lean/Cairn/Optimistic/Claims.lean:215
commute : Claims.Invariant machine

^1112 Replies for different keys commute (invariant)

Two inputs about different keys, in either order, leave the table the same at every key, and each gives the outputs it gives alone, so the two orders' outputs are the same two lists swapped.

def

Cairn.Optimistic.Claims.commute.info

lean/Cairn/Optimistic/Claims.lean:215
info : ClaimInfo

The human half of claim ^1112.

theorem

Cairn.Optimistic.Claims.commute.init

provedlean/Cairn/Optimistic/Claims.lean:215
init : holds machine.init

^1112 holds in the initial state.

theorem

Cairn.Optimistic.Claims.commute.reachable

provedlean/Cairn/Optimistic/Claims.lean:215
reachable (s✝ : Claims.StateOf machine) :
  machine.Reachable s✝ → holds s✝

^1112 holds in every reachable state.

def

Cairn.Optimistic.Claims.commute.holds

lean/Cairn/Optimistic/Claims.lean:215
holds (s : Claims.StateOf machine) : Prop

^1112 Replies for different keys commute: Two inputs about different keys, in either order, leave the table the same at every key, and each gives the outputs it gives alone, so the two orders' outputs are the same two lists swapped.

theorem

Cairn.Optimistic.Claims.commute.step

provedlean/Cairn/Optimistic/Claims.lean:215
step (s✝ : Claims.StateOf machine) (a✝ : Action) :
  holds s✝ → holds (machine.update s✝ a✝).fst

Every update, so every move, preserves ^1112.

theorem

Cairn.Optimistic.Claims.commute.reachableAll

provedlean/Cairn/Optimistic/Claims.lean:215
reachableAll (s✝ : Claims.StateOf machine) :
  machine.ReachableAll s✝ → holds s✝

^1112 holds in every state reachable by actions and messages from the world.

theorem

Cairn.Optimistic.Claims.commute.receive

provedlean/Cairn/Optimistic/Claims.lean:215
receive (s✝ : Claims.StateOf machine) (m✝ : Msg) :
  holds s✝ → holds (machine.receive s✝ m✝).fst

Every message from the world preserves ^1112.

^1113

A settled count is the server's

invariantproved
Does

For a view whose count is other people's o plus the person's own [v], a settled key shows o + [what the server holds]: exactly the server's count when no one else acted since the view. The count shown, c − [v] + [shown], is never below zero, and never below the person's own [shown].

Formal statement
holds s := Good s ∧
  ∀ (k o : Nat) (v : Bool),
    s.table.settled k = true →
      count (o + ind v) v (s.table.shown k) = o + ind (World.reg s k) ∧
        ind (s.table.shown k) ≤ count (o + ind v) v (s.table.shown k)
proved
5 theorems (init, step, receive, reachable, reachableAll), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
Proofs
✓ counts.init init
✓ counts.step step
✓ counts.receive receive
✓ counts.reachable reachable
✓ counts.reachableAll reachableAll

lean/Cairn/Optimistic/Claims.lean:224 · counts · ledger: active

8 generated declarations
def

Cairn.Optimistic.Claims.counts.info

lean/Cairn/Optimistic/Claims.lean:224
info : ClaimInfo

The human half of claim ^1113.

theorem

Cairn.Optimistic.Claims.counts.receive

provedlean/Cairn/Optimistic/Claims.lean:224
receive (s✝ : Claims.StateOf machine) (m✝ : Msg) :
  holds s✝ → holds (machine.receive s✝ m✝).fst

Every message from the world preserves ^1113.

theorem

Cairn.Optimistic.Claims.counts.init

provedlean/Cairn/Optimistic/Claims.lean:224
init : holds machine.init

^1113 holds in the initial state.

theorem

Cairn.Optimistic.Claims.counts.reachable

provedlean/Cairn/Optimistic/Claims.lean:224
reachable (s✝ : Claims.StateOf machine) :
  machine.Reachable s✝ → holds s✝

^1113 holds in every reachable state.

theorem

Cairn.Optimistic.Claims.counts.step

provedlean/Cairn/Optimistic/Claims.lean:224
step (s✝ : Claims.StateOf machine) (a✝ : Action) :
  holds s✝ → holds (machine.update s✝ a✝).fst

Every update, so every move, preserves ^1113.

def

Cairn.Optimistic.Claims.counts

lean/Cairn/Optimistic/Claims.lean:224
counts : Claims.Invariant machine

^1113 A settled count is the server's (invariant)

For a view whose count is other people's o plus the person's own [v], a settled key shows o + [what the server holds]: exactly the server's count when no one else acted since the view. The count shown, c − [v] + [shown], is never below zero, and never below the person's own [shown].

def

Cairn.Optimistic.Claims.counts.holds

lean/Cairn/Optimistic/Claims.lean:224
holds (s : Claims.StateOf machine) : Prop

^1113 A settled count is the server's: For a view whose count is other people's o plus the person's own [v], a settled key shows o + [what the server holds]: exactly the server's count when no one else acted since the view. The count shown, c − [v] + [shown], is never below zero, and never below the person's own [shown].

theorem

Cairn.Optimistic.Claims.counts.reachableAll

provedlean/Cairn/Optimistic/Claims.lean:224
reachableAll (s✝ : Claims.StateOf machine) :
  machine.ReachableAll s✝ → holds s✝

^1113 holds in every state reachable by actions and messages from the world.

^1114

A view never moves a written key

invariantproved
Does

A value in a view the app fetched, which may be stale (fetched before a write, or from a server that hasn't indexed it yet), never changes what a key written this session shows, or its confirmed value.

Formal statement
holds s := ∀ (k : Nat) (v : Bool),
  s.table.written k = true →
    (s.table.feed (Input.seen k v)).fst.shown k = s.table.shown k ∧
      (s.table.feed (Input.seen k v)).fst.server k = s.table.server k
proved
5 theorems (init, step, receive, reachable, reachableAll), standard axioms only.
not fuzzed
No build/fuzz/Cairn.json: run cairn fuzz.
not tested
Cairn has no conformance generator yet (tools/conformance/lean/Conformance/Apps/Cairn.lean).
Proofs

lean/Cairn/Optimistic/Claims.lean:233 · viewKeepsWritten · ledger: active

8 generated declarations
theorem

Cairn.Optimistic.Claims.viewKeepsWritten.step

provedlean/Cairn/Optimistic/Claims.lean:233
step (s✝ : Claims.StateOf machine) (a✝ : Action) :
  holds s✝ → holds (machine.update s✝ a✝).fst

Every update, so every move, preserves ^1114.

theorem

Cairn.Optimistic.Claims.viewKeepsWritten.reachable

provedlean/Cairn/Optimistic/Claims.lean:233
reachable (s✝ : Claims.StateOf machine) :
  machine.Reachable s✝ → holds s✝

^1114 holds in every reachable state.

theorem

Cairn.Optimistic.Claims.viewKeepsWritten.reachableAll

provedlean/Cairn/Optimistic/Claims.lean:233
reachableAll (s✝ : Claims.StateOf machine) :
  machine.ReachableAll s✝ → holds s✝

^1114 holds in every state reachable by actions and messages from the world.

def

Cairn.Optimistic.Claims.viewKeepsWritten.info

lean/Cairn/Optimistic/Claims.lean:233
info : ClaimInfo

The human half of claim ^1114.

def

Cairn.Optimistic.Claims.viewKeepsWritten.holds

lean/Cairn/Optimistic/Claims.lean:233
holds (s : Claims.StateOf machine) : Prop

^1114 A view never moves a written key: A value in a view the app fetched, which may be stale (fetched before a write, or from a server that hasn't indexed it yet), never changes what a key written this session shows, or its confirmed value.

theorem

Cairn.Optimistic.Claims.viewKeepsWritten.init

provedlean/Cairn/Optimistic/Claims.lean:233
init : holds machine.init

^1114 holds in the initial state.

def

Cairn.Optimistic.Claims.viewKeepsWritten

lean/Cairn/Optimistic/Claims.lean:233
viewKeepsWritten : Claims.Invariant machine

^1114 A view never moves a written key (invariant)

A value in a view the app fetched, which may be stale (fetched before a write, or from a server that hasn't indexed it yet), never changes what a key written this session shows, or its confirmed value.

theorem

Cairn.Optimistic.Claims.viewKeepsWritten.receive

provedlean/Cairn/Optimistic/Claims.lean:233
receive (s✝ : Claims.StateOf machine) (m✝ : Msg) :
  holds s✝ → holds (machine.receive s✝ m✝).fst

Every message from the world preserves ^1114.

Definitions 6

abbrev

Cairn.Optimistic.Claims.W

lean/Cairn/Optimistic/Claims.lean:42
W : Type

The harness's world: keys are numbers, values booleans.

def

Cairn.Optimistic.Claims.pick

lean/Cairn/Optimistic/Claims.lean:45
pick (s : W) (i : Nat) : Option (Nat × Pkt Bool)

The packet the i-th place in the network holds, if any.

def

Cairn.Optimistic.Claims.onPkt

lean/Cairn/Optimistic/Claims.lean:48
onPkt (s : W) (i : Nat) (f : W → Nat → Pkt Bool → W) : W

Act on the i-th packet, if there is one.

def

Cairn.Optimistic.Claims.machine

lean/Cairn/Optimistic/Claims.lean:147
machine : Claims.Machine W
def

Cairn.Optimistic.Claims.Good

lean/Cairn/Optimistic/Claims.lean:150
Good (s : W) : Prop

The server model's invariant, with same the harness's equality.

def

Cairn.Optimistic.Claims.claimInfos

lean/Cairn/Optimistic/Claims.lean:241
claimInfos : List ClaimInfo

Theorems 10

theorem

Cairn.Optimistic.Claims.onPkt_ok

provedlean/Cairn/Optimistic/Claims.lean:53
onPkt_ok {s : W} (h : World.Ok s) (i : Nat)
  {f : W → Nat → Pkt Bool → W} (hf : ∀ (k : Nat) (p : Pkt Bool), World.Ok (f s k p)) :
  World.Ok (onPkt s i f)
theorem

Cairn.Optimistic.Claims.onPkt_eq

provedlean/Cairn/Optimistic/Claims.lean:59
onPkt_eq {s : W} (i : Nat) {f : W → Nat → Pkt Bool → W}
  {P : W → Prop} (hf : ∀ (k : Nat) (p : Pkt Bool), P (f s k p)) (hs : P s) : P (onPkt s i f)
theorem

Cairn.Optimistic.Claims.serve_table

provedlean/Cairn/Optimistic/Claims.lean:65
serve_table (s : W) (k : Nat) (p : Pkt Bool) :
  (World.serve s k p).table = s.table
theorem

Cairn.Optimistic.Claims.refuse_table

provedlean/Cairn/Optimistic/Claims.lean:70
refuse_table (s : W) (k : Nat) (p : Pkt Bool) :
  (World.refuse s k p).table = s.table ∧ (World.refuse s k p).srv = s.srv
theorem

Cairn.Optimistic.Claims.deliver_srv

provedlean/Cairn/Optimistic/Claims.lean:76
deliver_srv (s : W) (k : Nat) (p : Pkt Bool) :
  (World.deliver s k p).srv = s.srv
theorem

Cairn.Optimistic.Claims.lose_srv

provedlean/Cairn/Optimistic/Claims.lean:81
lose_srv (s : W) (k : Nat) (p : Pkt Bool) :
  (World.lose s k p).srv = s.srv
theorem

Cairn.Optimistic.Claims.init_good

provedlean/Cairn/Optimistic/Claims.lean:152
init_good : Good machine.init
theorem

Cairn.Optimistic.Claims.onPkt_good

provedlean/Cairn/Optimistic/Claims.lean:154
onPkt_good {s : W} (h : Good s) (i : Nat)
  {f : W → Nat → Pkt Bool → W} (hf : ∀ (k : Nat) (p : Pkt Bool), World.Ok (f s k p))
  (hs : ∀ (k : Nat) (p : Pkt Bool), (f s k p).table.same = s.table.same) :
  Good (onPkt s i f)
theorem

Cairn.Optimistic.Claims.update_good

provedlean/Cairn/Optimistic/Claims.lean:160
update_good (s : W) (a : Action) :
  Good s → Good (machine.update s a).fst

Every move keeps Good.

theorem

Cairn.Optimistic.Claims.Good.converges

provedlean/Cairn/Optimistic/Claims.lean:174
converges {s : W} (h : Good s) (k : Nat)
  (hk : s.table.settled k = true) : s.table.shown k = World.reg s k