aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--docs/federation.md501
1 files changed, 261 insertions, 240 deletions
diff --git a/docs/federation.md b/docs/federation.md
index aadaca1..3eb6a8d 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -118,8 +118,9 @@ What is not promised:
counts until a key above it cuts it off; then all of it stops counting (Cuts), and a
user it created or vouched for goes out as by an unvouch, its names waiting until it
is gone; but a user another vouches for stays in, with what it claimed: a thief's
- accomplice keeps the thief's sock in. Past what became final meanwhile, and past a
- remake, it stays.
+ accomplice keeps the thief's sock in, and so does a root's node that witnesses for
+ it after the cut, in the open. Past what became final meanwhile, and past a remake,
+ it stays.
* **Agreement in the classic sense, for what users write.** There is no quorum there,
so no n ≥ 3f+1: promises 1 to 4 and 6 hold against any number of malicious parties,
and 5 from when a root saw the claim. Only decisions take two thirds, and only the
@@ -158,13 +159,13 @@ What is not promised:
more than a third of the voters (Partitions). Every node holds that number, but each
took the base up when it reached it, and gets the decision when it does: whoever
holds the last record can show it when some honest nodes are past that and some
- aren't, and splits them for a while. The split shows, and heals: every node follows
- once those carry records count for more than a third, or those that followed go
- back, `remakeAge` later, and their users sign again what they wrote there. And
- voters who split their votes between two remakes, neither getting more than two
- thirds, end the epoch's remakes: those left go apart (Going apart). One voter can
- split them: clients keep honest votes on one remake, but a twin proposal made while
- honest voters vote, within the same minutes, splits those.
+ aren't, and splits them. The split shows, and heals once those carry records count
+ for more than a third; until then those that followed stay, or go back by their
+ operators' word, their users signing again what they wrote there. And voters who
+ split their votes between two remakes, neither getting more than two thirds, end the
+ epoch's remakes: those left go apart (Going apart). One voter can split them:
+ clients keep honest votes on one remake, but a twin proposal made while honest
+ voters vote, within the same minutes, splits those.
* **Decisions without the voters.** With a third of an epoch's voters not taking
part (gone, silent, without a node that carries for them), nothing more is decided
there; what users write goes on. Those left go apart (Going apart).
@@ -259,11 +260,12 @@ go, and they stay what they are today.
Nothing constrains them, and a number that makes no sense has the result it has. A
time of nothing is "at once"; a limit of nothing lets nothing more in; a `baseAge` of
nothing takes a base that lacks nothing. Three end deciding itself: a
-`fractions.decide` of 1, `limits.proposals` at 0, a `window` of nothing. What is left
-then is refusing that decision, or going apart. A proposal that leaves a number
-without a value where it needs one is no proposal. More than a share is strictly more;
-a share of the voters, for what was seen for long, is the fewest voters that are that
-share at least, and one at least.
+`fractions.decide` of 1, `limits.proposals` at 0, a `window` of nothing; a `remakeAge`
+of nothing ends remaking, as nobody follows a remake at once. What is left then is
+refusing that decision, or going apart. A proposal that leaves a number without a
+value where it needs one is no proposal. More than a share is strictly more; a share
+of the voters, for what was seen for long, is the fewest voters that are that share at
+least, and one at least.
Where this text says two thirds and a third, it means the two fractions as
recommended. What is promised of decisions is argued for those; a swarm that sets
@@ -284,7 +286,7 @@ grows. A statement is signed by one user and says one thing:
| `key` | the user | one more key |
| `retire` | the user | a key, and the cut after which what it signed doesn't count |
| `node` | the user | a node that carries for it; or one that stops, with a cut |
-| `release` | the user | a claim, a vote or a proposal of its own given up; or itself; a root's `create` for a user the root change holds |
+| `release` | the user | a claim, a vote or a proposal of its own given up; or itself |
| `claim` | the user | a name it wants (Claims; in the name's own register) |
| `propose`, `vote` | a voter (a fork: any user) | Decisions |
@@ -305,19 +307,21 @@ grows. A statement is signed by one user and says one thing:
a root's `create` for that name gives it its first keys. That is no other user. Such
creations are claims of one thing, ordered as claims of a name are (Two claims): one
signed in sight of another that stands is refused, one late against another is late
- for good, and of two that contest each other neither gives keys until one is
- released, by its root, or the voters say which. So a root that comes later than
+ for good, and of two that contest each other neither gives keys until the voters say
+ which (they give first keys anew: Decisions). So a root that comes later than
another to give keys gives none, and of two that answer at once, each root's node
- seeing its own first, neither does until one of them releases its own. A root
- releases its `create` only while it contests another's: once one gives keys, they
- are the user's, which gives itself up as any user does.
+ seeing its own first, neither does. No root releases its `create`: once one gives
+ keys, they are the user's, which gives itself up as any user does.
* **A user's own name, by its own key.** A user claims its own name as a name of the
kind `user`, signed with its own key: a claim of what it has already. It counts
toward no limit, a user has one at a time, and it holds the name on where its
creation no longer does (its creator's key cut off: Cuts). It is valid only where a
rule of the kind `user` would let the user itself create that name: a name kept for
- one creator's creations goes with that creator's cut. A creation of the name in its
- sight is refused, as a claim is. Clients make it right after a creation.
+ one creator's creations goes with that creator's cut, and where only the roots
+ create users, no user's name outlasts its creator's cut but by what a root's node
+ witnessed. A rule that changes by a decision uncovers own-name claims as it uncovers
+ any claim. A creation of the name in its sight is refused, as a claim is. Clients
+ make it right after a creation.
* **Keys form a tree.** A user's first keys are those its creation names. A `key`
statement adds one, signed with a key the user has, which is **above** the new one,
as are the keys above itself. Any number over time; at once as many as
@@ -348,19 +352,20 @@ grows. A statement is signed by one user and says one thing:
counts the writers each user's nodes start in the epoch: past `limits.writers`, a
change that starts another is put off by every node that would take it from that
user's nodes, until a remake. A node's writers count for one user: the one its
- member entry names, of those it carries for there, its own word, carried over a
- remake with the entry; naming none of them, the user of the `node` statement naming
- it with the lowest digest, of those that count there, so that its operator names one
- to choose. So a user past its limit puts off the nodes whose writers count for it,
- and no other that carries for it too. It is never refused: put off is each node's
- doing, its operator may take what it puts off, and a change that reaches a node
- within another's history is taken. Writers a node started outside a cut it was
- stopped with count for nobody: a thief's node costs its victim nothing once cut off.
- A writer is a run, not a write: with a thousand, three nodes each crash or rejoin
- daily for most of a year. A node whose writers count for a user past it is put off
- as a whole, with what it carries for others and its records of proposals, until a
- remake or its operator takes what is put off; how many a user's nodes started shows
- (`GET /registry/users`), for a remake to come first.
+ member entry names, of those it carries for, where each writer starts (a writer
+ counted stays so), its own word, carried over a remake with the entry; naming none
+ of them, the user of the `node` statement naming it with the lowest digest, of those
+ that count there, so that its operator names one to choose. So a user past its limit
+ puts off the nodes whose writers count for it, and no other that carries for it too.
+ It is never refused: put off is each node's doing, its operator may take what it
+ puts off, and a change that reaches a node within another's history is taken.
+ Writers a node started outside a cut it was stopped with count for nobody: a thief's
+ node costs its victim nothing once cut off. A writer is a run, not a write: with a
+ thousand, three nodes each crash or rejoin daily for most of a year. A node whose
+ writers count for a user past it is put off as a whole, with what it carries for
+ others and its records of proposals, until a remake or its operator takes what is
+ put off; how many a user's nodes started shows (`GET /registry/users`), for a remake
+ to come first.
* **A party's budget.** A node takes changes from a party's nodes no faster than a
budget, its own setting: what is over waits, and nothing is refused for it. For a
budget a party is a user with the users below it that no line reaches but through
@@ -769,13 +774,13 @@ it is doesn't depend on who asks or when: a change's history is fixed by its has
* **A vouch or a creation taken back.** A `vouch` or a `create` outside a cut stops
counting as an unvouch by its signer would, signed where the statement that set the
cut was (a decision's: its proposal): what the user signed counts through it where
- that statement was signed in sight of it, or where a node of the signer committed a
- change with it in its history and not that statement (Unvouching); a root's doesn't
- count here, as against an unvouch: the signer is the one a cut protects, and needs
- no witness against itself. With another vouch standing, the user stays in, with its
- keys, its claims and the users it brought in. Without, it is out from there: its
- names wait, final ones too, and it is gone once seen out for `gone`, unless a vouch
- comes.
+ that statement was signed in sight of it, or where a node of the signer or of a root
+ committed a change with it in its history and not that statement (Unvouching): a
+ signer that turns on what it created cuts as it would unvouch, and the roots' nodes
+ witness against both. A root's node that witnesses so for a thief's sock keeps the
+ sock in, in the open. With another vouch standing, the user stays in, with its keys,
+ its claims and the users it brought in. Without, it is out from there: its names
+ wait, final ones too, and it is gone once seen out for `gone`, unless a vouch comes.
* **A creation is also a claim.** A `create` outside a cut is taken back as the claim
of the user's name too; not as the user: its ID and first keys are what the creation
names, and a vouch names a user by its ID. Its name the user keeps where it claimed
@@ -790,11 +795,11 @@ that does, the one that does is read again (Resolving).
The price: a key above retiring one below with an early cut takes back what that key
signed since, a release among them, further back than an unvouch reaches; a vouch or a
creation no further than its signer's unvouch would, signed where the retirement was,
-so a user brought in goes out, its names waiting. Whoever relies on another's
-statement relies on that, until what it holds is final: a second vouch is what keeps a
-user in, whatever becomes of its creator's keys. And a user's first keys have none of
-its own above them: above those are the voters, who give a user first keys anew by a
-decision (Decisions).
+with the same witnesses, so a user brought in goes out, its names waiting. Whoever
+relies on another's statement relies on that, until what it holds is final: a second
+vouch is what keeps a user in, whatever becomes of its creator's keys. And a user's
+first keys have none of its own above them: above those are the voters, who give a
+user first keys anew by a decision (Decisions).
Any key of a user signs for it, so a device key in the wrong hands unvouches whom
the user brought in and releases its names. A key above takes all of that back with
@@ -1027,9 +1032,9 @@ which every node works out itself.
within `remakeAge` of taking its base up; past that, once the new epoch's carry
records count for more than a third of the voters (Partitions). Voters who split
between two remakes, neither getting more than two thirds, end the epoch's remakes:
- those left go apart (Going apart). No node, having switched, moves again by itself,
- but back from a remake its carry records didn't bear (Partitions): where it finds
- another remake of the epoch it left decided, it shows it, and its operator says.
+ those left go apart (Going apart). No node, having switched, moves again by itself:
+ where it finds another remake of the epoch it left decided, it shows it, and its
+ operator says.
* **Every node builds the snapshot** itself once the remake is decided, from the base
as it holds it, and switches after the switch delay, as today. The snapshot holds
the registry as it resolves at the base:
@@ -1085,11 +1090,11 @@ which every node works out itself.
witnessed comes as 32 bytes a node.
* **A carry record witnesses** as the node's changes did in the epoch before: as a
change with what it names in its history, standing or not as it says. Against a
- claim, where a node of that claim's side committed it; for an unvouch, where a
- node of the unvoucher or of a root did. So a claim that turns up later as signed
- in the epoch before is late against what a root's node's record names, and
- nothing rests on the order a node writes in. Against a claim the snapshot holds,
- what is carried over gives way.
+ claim, where a node of that claim's side committed it; for an unvouch, or a vouch or
+ a creation cut off, where a node of its signer or of a root did. So a claim that
+ turns up later as signed in the epoch before is late against what a root's node's
+ record names, and nothing rests on the order a node writes in. Against a claim the
+ snapshot holds, what is carried over gives way.
* **Its order and its numbers.** Of a user's statements of one kind, and of the
proposals of a matter, those the snapshot holds come first, then those carried
over, by the numbers they state, then those signed in the new epoch. So a number
@@ -1352,9 +1357,8 @@ A change is valid if, in the document at its dependencies:
signer of what it takes back, or by a root for what is the seats'. `retire`, a node
stopping: by a key above, or by the key itself as said under Cuts, the cut in the
change's history, and its list what the key signed within it. `release`: by the
- user of what it releases; of the user itself, with a first key; of a root's
- `create` for a user the root change holds, by that root, while it contests another
- root's there.
+ user of what it releases; of the user itself, with a first key; never of a root's
+ `create` for a user the root change holds.
6. A `claim`: of the kind `user`, only by the user of that name, of its own name,
while no claim of its own of it stands there, where a rule of the kind lets the
user create that name. Else the kind is declared, the name is one of it, a rule
@@ -1409,19 +1413,19 @@ the steps before:
`create` or `vouch` for it whose signer counts there by a line that doesn't pass
through the user (so this ends), where the statement is within what every `unvouch`
of that one leaves and, where that one is outside a cut, what the statement that
- set the cut leaves, as an unvouch would with the signer's nodes alone as witnesses
- (Cuts); what is the seats' is taken back once every root unvouched it. A statement
- counts if its user counts at it (a proposal and a vote: always, for a voter); its
- key was the user's (added by statements that count, up to its creation, which gives
- its first keys whether or not it counts as a vouch, or given by a decision); it is
- within every cut set for that key (by a `retire` that counts, or a decision); a
- node carrying for the user committed it (any node, for what any node commits),
- within that node's cut if it has one; and it isn't past its limit (Users), by the
- limit that holds. A `retire`, a stop and an `unvouch` are never outside a cut they
- set themselves, nor left out with their carrier. A user is **out** where it counts
- through no `create` or `vouch` any more, or where it gave itself up. It is **gone**
- once seen out for `gone`, or where a decision freed its name; and gone it stays,
- whatever is vouched or cut off after.
+ set the cut leaves, as an unvouch would (Cuts); what is the seats' is taken back
+ once every root unvouched it. A statement counts if its user counts at it (a
+ proposal and a vote: always, for a voter); its key was the user's (added by
+ statements that count, up to its creation, which gives its first keys whether or
+ not it counts as a vouch, or given by a decision); it is within every cut set for
+ that key (by a `retire` that counts, or a decision); a node carrying for the user
+ committed it (any node, for what any node commits), within that node's cut if it
+ has one; and it isn't past its limit (Users), by the limit that holds. A `retire`,
+ a stop and an `unvouch` are never outside a cut they set themselves, nor left out
+ with their carrier. A user is **out** where it counts through no `create` or
+ `vouch` any more, or where it gave itself up. It is **gone** once seen out for
+ `gone`, or where a decision freed its name; and gone it stays, whatever is vouched
+ or cut off after.
3. **Users' names.** A creation stands while it counts, isn't released, its user isn't
gone, and a rule of the kind `user` lets its signer; a user's claim of its own name
stands with it, and on where the creation doesn't. Of what stands for a name: the
@@ -1495,20 +1499,28 @@ more than a third of the voters voting for both (Remakes).
decision within it follow, those past it wait in the epoch. It shows on both sides:
those that wait hold the decision and see peers in the new epoch; those that followed
see peers in the old one, the decision in their history (`GET /peers`, the dashboard).
-It heals by the new epoch's carry records, which count for the voters each node
-carries for, read alike by every node, and only grow:
+It heals by the new epoch's carry records, counted as what was seen for long is: a
+node for one voter, of the voters of the epoch that decided the remake, each record as
+it stood where it was written (a stop with a cut after it takes nothing back). A node
+that waits fetches them from peers in the new epoch and judges them against the
+snapshot it builds from the base it holds. Read so, alike by every node, they only
+grow:
-* Once they count for more than a third of the voters, every node in the old epoch
- follows, past `remakeAge` or not: a node of an honest voter got the decision in
- time, and the malicious alone count for less.
-* While they count for no more than a third, `remakeAge` after a node followed, it
- goes back: it drops the new epoch, as a node comes back from changes the others
- refuse (below), and what its users signed there goes to the quarantine, to be signed
- again in the epoch it is back in.
-* A node that went back follows again should they count for more than a third later.
- So every honest node ends in one epoch, whichever it is. A remake shown long after
- its time gets no honest node's carry record, and nobody but the malicious follows
- it.
+* Once they count for more than a third of the voters, every node that waits follows:
+ a node of an honest voter took it up in time, and the malicious alone count for
+ less. A node whose operator refused the remake, by hand or by its bounds, doesn't:
+ the heal moves only those that wait by `remakeAge`.
+* While they count for no more, the split stays, shown on both sides. A node that
+ followed goes back only by its operator's word, as to any older epoch: it drops the
+ new epoch, as a node comes back from changes the others refuse (below), and what its
+ users signed there goes to the quarantine, to be signed again in the epoch it is
+ back in. Should the count cross a third later, it follows again, its carry record
+ there the one it wrote before.
+
+The malicious choose when a split starts, by when they show the last record; not that
+the honest go back and forth, nor whether they follow, which takes nodes of honest
+voters. An epoch the honest nodes stay in, its voters' remake votes spent, moves on by
+word, not by votes.
**Changes one side refuses** are a partition nobody chose. A node is cut off from the
others when it holds a change they refuse, as everything it writes after builds on
@@ -1731,8 +1743,13 @@ a write is refused only by what its own history holds, and counts from the start
carry record, so what any honest node held comes along. And a voter's vote names its
base, once an epoch: two bases are both decided only where more than a third of the
voters signed for both.
-* *Nobody is moved.* A node refuses any decision by its operator's word or bounds,
- and follows a fork by its operator's word alone.
+* *Nobody is moved.* A node refuses any decision by its operator's word or bounds, and
+ follows a fork by its operator's word alone. A node that waits by `remakeAge`
+ follows once the new epoch's carry records count for more than a third of V, a node
+ for one voter, as each stood where written: one at least an honest voter's node that
+ took the remake up in time. Fewer than a third, writing records as they like, move
+ nobody, and nobody goes back but by its operator's word: so every honest node that
+ waits ends where the honest that followed are, once they are enough.
* *With other fractions.* Write d for `fractions.decide` and s for `fractions.seen`.
A decision no honest voter voted for takes d of the voters malicious. Two
proposals of one matter both decided, with nobody changing their mind, take more
@@ -2049,175 +2066,178 @@ Statements and users:
| 4 | Offers a statement again; or an envelope signed for another swarm, epoch, path or user ID | Nothing where it is there under its digest; refuse elsewhere | 3 | unit, exists for swarm and path: `what_an_envelope_must_be`; `signed_for_its_user_id_and_epoch` |
| 5 | Commits a statement a second time, in a change with other dependencies, to move it | A statement is where it says its signer was (`seen`), whoever carries it and how often: nothing moves | 2 | unit: `a_statement_carried_twice` |
| 6 | Creates a user listing a victim's public key beside its own | The victim's envelopes name the victim's ID: they count for no other | 3 | unit: `a_key_in_two_creations` |
-| 7 | A second root signs a `create`, with keys of its own, for a user the root change holds, saying it saw nothing of the first | Refuse where the user has keys. Out of sight the two are ordered as claims are: each root's node saw its own first, so the two contest and neither gives keys, until a root releases its own or the voters give first keys | 3 | unit: `first_keys_by_claim_order` |
-| 8 | A root releases the `create` that gave a moved-in user its first keys, after the user signed with them, and gives it keys of its own | Refuse: a root releases its `create` for such a user only while it contests another root's; once one gives keys, they are the user's | 3, 5 | unit: `a_root_keeps_to_its_create` |
-| 9 | Users vouch for each other in a ring away from the roots; a user vouches for its creator | None is vouched for by it | 3 | unit, resolve: `no_line_no_user` |
-| 10 | Creates a name in sight of its creation | Refuse | 4 | unit: `a_name_created_once` |
-| 11 | Creates a user of a name another user holds by its claim of its own name; or signs that claim again and again, each kept by every node | Refuse: a creation of a name where a user's claim of its own name stands, as a claim is refused; a user has one such claim at a time | 4 | unit: `a_users_own_name_claimed_once` |
-| 12 | Creates a name another has, saying it saw nothing of it | Hold both; late once a root saw the first. Before: contested, or the first is late where a root's node got the other first | 4, 5 | unit: `a_backdated_creation_is_late` |
-| 13 | Gets a user's name contested to free its names | Its claims stand without the name | 5 | unit: `claims_stand_without_the_name` |
-| 14 | Creates many users, each claiming many names (sybils); creates them out of each other's sight to pass the limit | Refuse past the limits in sight; out of sight, those past them don't count. A limit bounds how many each user brings in itself, not how many come in below it: each shows below its creator, for all to see, and goes with it when it is unvouched | 6 | unit: `limits_on_creating`, `past_a_limit_out_of_sight` |
-| 15 | Adds keys, nodes or statements without end; signs and gives up without end (vouch and unvouch, claim and release, key and retire) | Refuse past the limits. What is given up counts toward none: it is taken no faster than a budget per party (row of the budget, stage 8), and a remake leaves it out | 6 | unit: `limits_on_a_register` |
-| 16 | Signs more than its limit out of each other's sight; another claims a name that so doesn't count; then gives the earlier ones up | What comes to count later than it was signed gives way to what was claimed in sight of it meanwhile | 5 | unit: `counting_late_gives_way` |
-| 17 | With a stolen key, signs statements that come before its user's own (keys, creations, claims), to push those past their limits; an accomplice claims the names that so show free | Until the key is cut off they do. What a cut leaves out comes before nothing: the user's own count again, and a claim of theirs that a root's node had seen hold is read as never down, so the accomplice's gives way | 3, 5 | unit: `cut_off_comes_before_nothing`, `down_by_a_limit_comes_back` |
-| 18 | Names another party's node as one that carries for it; offers that node a token of its own | A node carries only once it committed the statement naming it; an honest node takes tokens only from nodes its operator named | 3 | unit: `a_node_carries_by_its_own_word`, `a_token_of_ones_party` |
+| 7 | A second root signs a `create`, with keys of its own, for a user the root change holds, saying it saw nothing of the first | Refuse where the user has keys. Out of sight the two are ordered as claims are: each root's node saw its own first, so the two contest and neither gives keys, until the voters give first keys | 3 | unit: `first_keys_by_claim_order` |
+| 8 | A root releases the `create` that gave a moved-in user its first keys, after the user signed with them, and gives it keys of its own | Refuse: no root releases its `create` for such a user; once one gives keys, they are the user's. Two roots' creates contest until the voters give first keys | 3, 5 | unit: `a_root_keeps_to_its_create` |
+| 9 | A root makes its own `create` for a moved-in user contested by a twin on old dependencies, or signs a release on old dependencies once it is final, then gives the user keys of its own | Refuse: no root releases its `create`. The twin contests, in the open, until the voters give first keys; what the user signed with its keys stays | 3, 5 | unit: `a_root_keeps_to_its_create` |
+| 10 | Users vouch for each other in a ring away from the roots; a user vouches for its creator | None is vouched for by it | 3 | unit, resolve: `no_line_no_user` |
+| 11 | Creates a name in sight of its creation | Refuse | 4 | unit: `a_name_created_once` |
+| 12 | Creates a user of a name another user holds by its claim of its own name; or signs that claim again and again, each kept by every node | Refuse: a creation of a name where a user's claim of its own name stands, as a claim is refused; a user has one such claim at a time | 4 | unit: `a_users_own_name_claimed_once` |
+| 13 | Creates a name another has, saying it saw nothing of it | Hold both; late once a root saw the first. Before: contested, or the first is late where a root's node got the other first | 4, 5 | unit: `a_backdated_creation_is_late` |
+| 14 | Gets a user's name contested to free its names | Its claims stand without the name | 5 | unit: `claims_stand_without_the_name` |
+| 15 | Creates many users, each claiming many names (sybils); creates them out of each other's sight to pass the limit | Refuse past the limits in sight; out of sight, those past them don't count. A limit bounds how many each user brings in itself, not how many come in below it: each shows below its creator, for all to see, and goes with it when it is unvouched | 6 | unit: `limits_on_creating`, `past_a_limit_out_of_sight` |
+| 16 | Adds keys, nodes or statements without end; signs and gives up without end (vouch and unvouch, claim and release, key and retire) | Refuse past the limits. What is given up counts toward none: it is taken no faster than a budget per party (row of the budget, stage 8), and a remake leaves it out | 6 | unit: `limits_on_a_register` |
+| 17 | Signs more than its limit out of each other's sight; another claims a name that so doesn't count; then gives the earlier ones up | What comes to count later than it was signed gives way to what was claimed in sight of it meanwhile | 5 | unit: `counting_late_gives_way` |
+| 18 | With a stolen key, signs statements that come before its user's own (keys, creations, claims), to push those past their limits; an accomplice claims the names that so show free | Until the key is cut off they do. What a cut leaves out comes before nothing: the user's own count again, and a claim of theirs that a root's node had seen hold is read as never down, so the accomplice's gives way | 3, 5 | unit: `cut_off_comes_before_nothing`, `down_by_a_limit_comes_back` |
+| 19 | Names another party's node as one that carries for it; offers that node a token of its own | A node carries only once it committed the statement naming it; an honest node takes tokens only from nodes its operator named | 3 | unit: `a_node_carries_by_its_own_word`, `a_token_of_ones_party` |
Unvouching:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 19 | Unvouches a user it didn't vouch for; a root unvouches the users the root change holds, or those a root before it created | Refuse the first. What is the seats' is taken back once every root unvouched it: one root puts nobody out, where there are several | 3 | unit: `only_the_voucher_unvouches`, `the_seats_take_back_together` |
-| 20 | The roots unvouch the voters, and wait for them to be gone, to keep them from deciding | A voter votes for its epoch, in, out or gone, and the nodes of one that is out go on committing their records and nothing else: who votes is the remake's word, not its vouchers' | 7 | unit: `a_voter_votes_for_its_epoch`, `an_out_voters_node_records` |
-| 21 | Unvouches saying it saw little, to undo what the user did since | What its own nodes or a root's had seen of the user stays | as said under Unvouching | unit: `an_unvouch_undoes_nothing_seen` |
-| 22 | The unvouched user signs on, saying it saw nothing of the unvouch, or across a partition | Hold it as part of another's history only; it doesn't count; after healing every node finds the same | 2, 3 | unit: `past_an_unvouch`; sim: `an_unvouch_across_a_partition` |
-| 23 | A user is unvouched: what of those it brought in, and its names? | One that another vouched for stays in, without doing anything. The others are out from the same point; a vouch after brings them back whole. Their names wait | 4 | unit: `a_second_line_keeps_it`, `those_it_brought_in`, `a_vouch_brings_back` |
-| 24 | An unvouched user's nodes keep sending | Refused as peers; nothing taken from them | 6 | sim: `nothing_from_an_unvouched_node` |
-| 25 | Claims a name of a user that is out, or creates its user name | Refuse: the names wait until the user is gone, or a decision frees them or gives them away | 5 | unit: `names_wait_while_out` |
-| 26 | Has a user unvouched, then stamps its nodes `gone` apart at once, to free the names; carries for many voters to be many | Gone takes a third of the voters, each with a node, and a node counts for one | 5 | unit: `gone_by_a_third_of_the_voters`, `a_node_is_seen_for_one_voter` |
-| 27 | Shows a stamp later that lies, by its time, between two that counted, with the thing not so there | Between goes by the stamps' histories, not their times: it lies between nothing, and gone, final and dropped stay | 5 | unit: `between_two_stamps` |
-| 28 | Vouches for a gone user saying it saw nothing of that, over a name claimed since | Gone stays: no vouch brings it back | 4 | unit: `gone_stays_gone` |
-| 29 | Out, signs a claim that doesn't count; another claims the name in sight of it; a vouch brings the user back | It is back with what it signed, but the claim made in sight of one that didn't count doesn't give way to it; nor does a settled one that never saw it | 5 | unit: `back_but_not_over_a_later_claim` |
+| 20 | Unvouches a user it didn't vouch for; a root unvouches the users the root change holds, or those a root before it created | Refuse the first. What is the seats' is taken back once every root unvouched it: one root puts nobody out, where there are several | 3 | unit: `only_the_voucher_unvouches`, `the_seats_take_back_together` |
+| 21 | The roots unvouch the voters, and wait for them to be gone, to keep them from deciding | A voter votes for its epoch, in, out or gone, and the nodes of one that is out go on committing their records and nothing else: who votes is the remake's word, not its vouchers' | 7 | unit: `a_voter_votes_for_its_epoch`, `an_out_voters_node_records` |
+| 22 | Unvouches saying it saw little, to undo what the user did since | What its own nodes or a root's had seen of the user stays | as said under Unvouching | unit: `an_unvouch_undoes_nothing_seen` |
+| 23 | The unvouched user signs on, saying it saw nothing of the unvouch, or across a partition | Hold it as part of another's history only; it doesn't count; after healing every node finds the same | 2, 3 | unit: `past_an_unvouch`; sim: `an_unvouch_across_a_partition` |
+| 24 | A user is unvouched: what of those it brought in, and its names? | One that another vouched for stays in, without doing anything. The others are out from the same point; a vouch after brings them back whole. Their names wait | 4 | unit: `a_second_line_keeps_it`, `those_it_brought_in`, `a_vouch_brings_back` |
+| 25 | An unvouched user's nodes keep sending | Refused as peers; nothing taken from them | 6 | sim: `nothing_from_an_unvouched_node` |
+| 26 | Claims a name of a user that is out, or creates its user name | Refuse: the names wait until the user is gone, or a decision frees them or gives them away | 5 | unit: `names_wait_while_out` |
+| 27 | Has a user unvouched, then stamps its nodes `gone` apart at once, to free the names; carries for many voters to be many | Gone takes a third of the voters, each with a node, and a node counts for one | 5 | unit: `gone_by_a_third_of_the_voters`, `a_node_is_seen_for_one_voter` |
+| 28 | Shows a stamp later that lies, by its time, between two that counted, with the thing not so there | Between goes by the stamps' histories, not their times: it lies between nothing, and gone, final and dropped stay | 5 | unit: `between_two_stamps` |
+| 29 | Vouches for a gone user saying it saw nothing of that, over a name claimed since | Gone stays: no vouch brings it back | 4 | unit: `gone_stays_gone` |
+| 30 | Out, signs a claim that doesn't count; another claims the name in sight of it; a vouch brings the user back | It is back with what it signed, but the claim made in sight of one that didn't count doesn't give way to it; nor does a settled one that never saw it | 5 | unit: `back_but_not_over_a_later_claim` |
Namespaces:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 30 | Writes into another's namespace, signed by itself | Refuse, and the node as a whole | 3 | unit: `a_namespace_is_its_users`; sim, as `a_member_writing_against_the_rules` today |
-| 31 | Writes plain values, or protocol data but its own member entry | Refuse | 3 | unit: `nothing_plain` |
-| 32 | Puts an old envelope back | Refuse: it doesn't replace what is there | 3 | unit, exists: `what_an_envelope_must_be` |
-| 33 | A user with a late creation of a name writes in the namespace | Refuse where its change's history shows it lost the name; else hold it and leave it out | 3 | unit: `a_user_that_lost_its_name` |
+| 31 | Writes into another's namespace, signed by itself | Refuse, and the node as a whole | 3 | unit: `a_namespace_is_its_users`; sim, as `a_member_writing_against_the_rules` today |
+| 32 | Writes plain values, or protocol data but its own member entry | Refuse | 3 | unit: `nothing_plain` |
+| 33 | Puts an old envelope back | Refuse: it doesn't replace what is there | 3 | unit, exists: `what_an_envelope_must_be` |
+| 34 | A user with a late creation of a name writes in the namespace | Refuse where its change's history shows it lost the name; else hold it and leave it out | 3 | unit: `a_user_that_lost_its_name` |
Claims:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 34 | Claims a held name in sight of the claim | Refuse | 4 | unit, claims: `first_come_first_served` |
-| 35 | Claims a settled name saying it saw nothing of the claim, long after | Hold both; it is late, the holder holds | 5 | unit: `a_backdated_claim_is_late`; sim: `a_backdated_claim_loses` |
-| 36 | Two honest users claim on two sides of a partition | Hold both; every node finds the same: one holder, or contested; a release leaves one | 2, 4 | sim: `a_partition_heals_to_one_answer`; unit: `a_release_ends_a_contest` |
-| 37 | Claims `x.tv.r` as another; claims a top-level domain as another than a root; claims `wiki.r`, which the rules leave to the voters | Refuse: the kind's rule. A kept name needs no claim; a claim by a user that doesn't have the name its rule gives doesn't count | 4 | unit: `a_kinds_rules`, `a_kept_name`, `a_rule_goes_by_who_has_the_name` |
-| 38 | Claims past its limit, in sight or out of sight of its other claims | Refuse in sight; out of sight, those past the limit don't count | 4, 6 | unit: `a_limit_in_sight`, `past_a_limit_out_of_sight` |
-| 39 | Claims `TV.r` beside `tv.r`, or `10.243.foo.bar`; claims one address in two spellings | Refuse what has characters the kind doesn't name. Else a name is compared as written: the application claims one spelling and reads no other | 4 | unit: `a_kinds_characters`; argued (Claims) |
-| 40 | A root says it saw a rival first, after the claim is settled | The name is contested; the registry names the changes and the root, and marks it if it showed both orders. Once the claim is final: nothing | not promised; 5 once final | unit: `a_root_contests`; sim: `both_orders_show` |
-| 41 | Hands an honest node of a root or of the claimant, back from a day off, a rival before the claim | A node that comes back catches up with the peers it keeps before it writes. Where it wrote all the same: contested, until one releases or the voters say. Once the claim is final: nothing | not promised; 5 once final | sim: `a_node_handed_the_rival_first` |
-| 42 | Two claims made at once reach two roots' nodes in two orders | Each is late against the other: contested, and one releases | 4 | unit: `roots_that_saw_two_orders` |
-| 43 | Keeps silent while no root's node is up, then claims saying it saw nothing | Before the claim is settled: contested, or whichever reaches a root's node first holds. After: late. Final: it gives way | 5 | unit: `silence_before_settling` |
-| 44 | Releases a claim with a stolen key, an accomplice claims | Once the key is cut off the release doesn't count: the accomplice's claim, made in sight of the first, gives way, unless it is final by then | 3, 4 | unit: `a_release_cut_off` |
-| 45 | Signs a claim and cuts its key off at once, so that the name shows free; another claims it; then cuts off the key that cut | It comes back over nothing: no root's node saw it hold the name before it was down | 5 | unit: `a_planted_claim_comes_back_over_nothing` |
-| 46 | Signs claims of held names that say they saw nothing, to have each the moment its holder releases it, is gone, or the voters free it | A claim late against another that isn't late against it is late for good: it doesn't stand, and whoever comes first then has the name | 5 | unit: `late_for_good` |
-| 47 | A limit is lowered and raised again, or a policy uncovers and covers again; someone claims in between a name that so showed free | The claim made in sight of one that didn't stand keeps the name: the other gives way, though a root's node had seen it first | 5 | unit: `sight_decides_alone` |
-| 48 | Every root that saw a claim stops its node with a cut from before, and a rival is handed in | A final claim holds. One that isn't is as before the roots saw it: contested, or late | 5 once final; not promised before | unit: `final_against_the_roots` |
-| 49 | Stamps its nodes `final` apart at once, to make a claim final that doesn't hold, or holds only as it sees it | Final takes a third of the voters, each having held the claim as the holder at both stamps and between | 5 | unit: `final_by_a_third_of_the_voters` |
-| 50 | Keeps honest voters' nodes apart for longer than `final`, a claim of one name on each side | Both are final: contested, until one releases or the voters say whose it is | not promised | sim: `two_finals` |
+| 35 | Claims a held name in sight of the claim | Refuse | 4 | unit, claims: `first_come_first_served` |
+| 36 | Claims a settled name saying it saw nothing of the claim, long after | Hold both; it is late, the holder holds | 5 | unit: `a_backdated_claim_is_late`; sim: `a_backdated_claim_loses` |
+| 37 | Two honest users claim on two sides of a partition | Hold both; every node finds the same: one holder, or contested; a release leaves one | 2, 4 | sim: `a_partition_heals_to_one_answer`; unit: `a_release_ends_a_contest` |
+| 38 | Claims `x.tv.r` as another; claims a top-level domain as another than a root; claims `wiki.r`, which the rules leave to the voters | Refuse: the kind's rule. A kept name needs no claim; a claim by a user that doesn't have the name its rule gives doesn't count | 4 | unit: `a_kinds_rules`, `a_kept_name`, `a_rule_goes_by_who_has_the_name` |
+| 39 | Claims past its limit, in sight or out of sight of its other claims | Refuse in sight; out of sight, those past the limit don't count | 4, 6 | unit: `a_limit_in_sight`, `past_a_limit_out_of_sight` |
+| 40 | Claims `TV.r` beside `tv.r`, or `10.243.foo.bar`; claims one address in two spellings | Refuse what has characters the kind doesn't name. Else a name is compared as written: the application claims one spelling and reads no other | 4 | unit: `a_kinds_characters`; argued (Claims) |
+| 41 | A root says it saw a rival first, after the claim is settled | The name is contested; the registry names the changes and the root, and marks it if it showed both orders. Once the claim is final: nothing | not promised; 5 once final | unit: `a_root_contests`; sim: `both_orders_show` |
+| 42 | Hands an honest node of a root or of the claimant, back from a day off, a rival before the claim | A node that comes back catches up with the peers it keeps before it writes. Where it wrote all the same: contested, until one releases or the voters say. Once the claim is final: nothing | not promised; 5 once final | sim: `a_node_handed_the_rival_first` |
+| 43 | Two claims made at once reach two roots' nodes in two orders | Each is late against the other: contested, and one releases | 4 | unit: `roots_that_saw_two_orders` |
+| 44 | Keeps silent while no root's node is up, then claims saying it saw nothing | Before the claim is settled: contested, or whichever reaches a root's node first holds. After: late. Final: it gives way | 5 | unit: `silence_before_settling` |
+| 45 | Releases a claim with a stolen key, an accomplice claims | Once the key is cut off the release doesn't count: the accomplice's claim, made in sight of the first, gives way, unless it is final by then | 3, 4 | unit: `a_release_cut_off` |
+| 46 | Signs a claim and cuts its key off at once, so that the name shows free; another claims it; then cuts off the key that cut | It comes back over nothing: no root's node saw it hold the name before it was down | 5 | unit: `a_planted_claim_comes_back_over_nothing` |
+| 47 | Signs claims of held names that say they saw nothing, to have each the moment its holder releases it, is gone, or the voters free it | A claim late against another that isn't late against it is late for good: it doesn't stand, and whoever comes first then has the name | 5 | unit: `late_for_good` |
+| 48 | A limit is lowered and raised again, or a policy uncovers and covers again; someone claims in between a name that so showed free | The claim made in sight of one that didn't stand keeps the name: the other gives way, though a root's node had seen it first | 5 | unit: `sight_decides_alone` |
+| 49 | Every root that saw a claim stops its node with a cut from before, and a rival is handed in | A final claim holds. One that isn't is as before the roots saw it: contested, or late | 5 once final; not promised before | unit: `final_against_the_roots` |
+| 50 | Stamps its nodes `final` apart at once, to make a claim final that doesn't hold, or holds only as it sees it | Final takes a third of the voters, each having held the claim as the holder at both stamps and between | 5 | unit: `final_by_a_third_of_the_voters` |
+| 51 | Keeps honest voters' nodes apart for longer than `final`, a claim of one name on each side | Both are final: contested, until one releases or the voters say whose it is | not promised | sim: `two_finals` |
Keys:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 51 | Steals a device key and signs with it | Take it until a key above cuts it off, then leave out what is outside the cut; a value it replaced is read again | 3 | unit: `a_retired_key_counts_within_its_cut`, `the_value_before_counts_again`; sim: `a_stolen_key_cut_off` |
-| 52 | Signs with a retired key, saying it saw nothing of the retiring | Hold it (valid as written), leave it out | 3 | unit: `backdated_past_a_cut` |
-| 53 | With a stolen device key, retires the keys above or beside it | Refuse | 3 | unit: `no_key_retires_one_above` |
-| 54 | With a stolen device key, retires that key from long ago, to undo what its user signed | Refuse: a key retires itself from where it stands | 3 | unit: `a_key_retires_itself_forward` |
-| 55 | A key retires itself; a retirement is carried by a node that only the retired key named; a node commits its own stop | Each counts: a cut never leaves out its own statement, nor the node that carried it | 2 | unit: `a_cut_never_reaches_itself` |
-| 56 | With a stolen key, retires the keys below it, stops nodes, unvouches, releases names | A key above cuts it off from before: all of it is taken back, but what became final on it | 3 | unit: `a_cut_takes_back_what_the_key_cut` |
-| 57 | Is unvouched with a key that is then cut off from before, and claimed names while out | In again, its earlier claims having stood all along; what it claimed while out gives way to what was claimed in sight of it meanwhile. Gone stays gone | 5 | unit: `an_unvouch_cut_off` |
-| 58 | Creates a user with a stolen key, under a name kept for its victim's creations, and has an accomplice vouch for it | Once the key is cut off, the creation no longer claims the name: the user stays in by the vouch, with its keys and claims, and without a name or a namespace | 3, 4 | unit: `a_creation_cut_off` |
-| 59 | With a device key, releases the user itself; with a stolen first key, does so before the voters can cut that key off | Refuse the first: it takes a first key. The second puts the user out, its names waiting, and a cut takes it back within `gone` | 3 | unit: `giving_up_takes_a_first_key`, `given_up_is_out_first` |
-| 60 | Steals a user's first key | The name is the thief's too, until a decision gives the user first keys anew, with a cut for the stolen one | 7 | unit: `first_keys_by_a_decision` |
-| 61 | Cuts its own key off early to take back a vouch or a release | It is taken back, but for what is final; a vouch as by its signer's unvouch, from where the retirement was signed: without a second vouch the user is out, its names waiting until it is gone or a vouch comes | not promised | unit: `a_second_vouch_stands` |
-| 62 | A key is retired on one side of a partition while it signs on the other | After healing, every node leaves out the same | 2 | sim: `a_cut_across_a_partition` |
-| 63 | Steals a node's key: commits changes as a witness | They count until the node is stopped with a cut, then not | 5 | unit: `a_stopped_node_witnesses_nothing` |
+| 52 | Steals a device key and signs with it | Take it until a key above cuts it off, then leave out what is outside the cut; a value it replaced is read again | 3 | unit: `a_retired_key_counts_within_its_cut`, `the_value_before_counts_again`; sim: `a_stolen_key_cut_off` |
+| 53 | Signs with a retired key, saying it saw nothing of the retiring | Hold it (valid as written), leave it out | 3 | unit: `backdated_past_a_cut` |
+| 54 | With a stolen device key, retires the keys above or beside it | Refuse | 3 | unit: `no_key_retires_one_above` |
+| 55 | With a stolen device key, retires that key from long ago, to undo what its user signed | Refuse: a key retires itself from where it stands | 3 | unit: `a_key_retires_itself_forward` |
+| 56 | A key retires itself; a retirement is carried by a node that only the retired key named; a node commits its own stop | Each counts: a cut never leaves out its own statement, nor the node that carried it | 2 | unit: `a_cut_never_reaches_itself` |
+| 57 | With a stolen key, retires the keys below it, stops nodes, unvouches, releases names | A key above cuts it off from before: all of it is taken back, but what became final on it | 3 | unit: `a_cut_takes_back_what_the_key_cut` |
+| 58 | Is unvouched with a key that is then cut off from before, and claimed names while out | In again, its earlier claims having stood all along; what it claimed while out gives way to what was claimed in sight of it meanwhile. Gone stays gone | 5 | unit: `an_unvouch_cut_off` |
+| 59 | Creates a user with a stolen key, under a name kept for its victim's creations, and has an accomplice vouch for it | Once the key is cut off, the creation no longer claims the name: the user stays in by the vouch, with its keys and claims, and without a name or a namespace | 3, 4 | unit: `a_creation_cut_off` |
+| 60 | With a device key, releases the user itself; with a stolen first key, does so before the voters can cut that key off | Refuse the first: it takes a first key. The second puts the user out, its names waiting, and a cut takes it back within `gone` | 3 | unit: `giving_up_takes_a_first_key`, `given_up_is_out_first` |
+| 61 | Steals a user's first key | The name is the thief's too, until a decision gives the user first keys anew, with a cut for the stolen one | 7 | unit: `first_keys_by_a_decision` |
+| 62 | Cuts its own key off early to take back a vouch or a release | It is taken back, but for what is final; a vouch as by its signer's unvouch, from where the retirement was signed: without a second vouch the user is out, its names waiting until it is gone or a vouch comes | not promised | unit: `a_second_vouch_stands` |
+| 63 | A key is retired on one side of a partition while it signs on the other | After healing, every node leaves out the same | 2 | sim: `a_cut_across_a_partition` |
+| 64 | Steals a node's key: commits changes as a witness | They count until the node is stopped with a cut, then not | 5 | unit: `a_stopped_node_witnesses_nothing` |
Decisions and remakes:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 64 | Forges a vote; votes as a user that isn't a voter, or one that is gone | Refuse | 7 | unit, decisions: `a_vote_is_a_voters` |
-| 65 | Brings in many users to vote, also while a remake's votes run | They vote only if a remake's list names them, which those who vote saw | 7 | unit: `who_votes` |
-| 66 | A remake's list of voters with the many users one user brought in; users put out between the votes and the base, to shrink the list | The voters see the list, by IDs, before they vote for it, and propose one of their own instead. Nothing after the proposal changes it | 7 | unit: `voters_are_the_remakes`, `a_list_is_fixed_when_signed` |
-| 67 | Records taking a proposal up without the votes, or with released ones | Refuse: every node judges a record against the votes in its history. A remake's record needs none: a remake is decided only by votes naming its base | 7 | unit: `a_record_needs_the_votes` |
-| 68 | Carries for many voters that have no node, and records with votes that ran out | Taken: nobody but the recording node reads a vote's end. A voter without a node is the party that carries for it, for a record; what is seen for long counts that node once | not promised | unit: `a_record_counts_for_its_voters`; argued (Decisions) |
-| 69 | Carries for a third of the voters, and keeps its records back: every decision waits, and comes on its day | The voters name another node, which records for them; their votes count meanwhile. A voter carried by nodes of two parties never waits for one. How many each node carries for shows | not promised | sim: `a_carrier_keeps_back` |
-| 70 | Keeps votes back until they ran out, or crafts them to look old, then shows them | No honest node takes the proposal up, and fewer than a third decide nothing. A remake's votes don't run out, and count when they come | 7 | unit: `taken_up_while_the_votes_run`; sim: `a_decision_from_the_past` |
-| 71 | Keeps its node's record back, and shows it weeks later: a proposal decided late | It holds only where none of its matter with a higher number was decided since: a node takes up nothing lower than it took up. What hangs shows, and the voters end it with a later proposal; not a remake's | not promised | unit: `nothing_lower_is_taken_up`; sim: `decided_late` |
-| 72 | Two proposals of one matter both decided: voters changed their minds, or a third voted both ways | Every node acts on the one with the higher number, the same from the same changes; the other shows as replaced | 7 | unit: `the_last_holds`; sim: `two_decided_one_holds` |
-| 73 | Makes a proposal saying it saw little or much, for a number of its choosing; grinds its digest; commits another's a second time | A number brings nothing without the votes of two thirds and their nodes' records; who votes is the epoch's, wherever a proposal is made; a second carrier changes nothing | 7 | unit: `a_proposal_is_where_it_was_signed` |
-| 74 | Stays away to hold decisions up | It counts on. A third staying away do hold them up: the rest go apart, naming who votes | 7 | unit: `two_thirds_of_all` |
-| 75 | Asks the voters for another user's first keys, saying it is that user | It takes two thirds of them, and the days a vote takes, shown to all; the user signs on meanwhile | not promised | argued (Decisions) |
-| 76 | Puts a voter's vote into a change of its own node; keeps one back; offers one again | Taken: the signature is the voter's. It counts while it runs; the register holds it once | 7 | unit: `a_vote_by_any_node` |
-| 77 | Signs a vote that says it runs out in ten years | A node counts no vote for longer than `window` from when it first held it; a remake's names its base and runs while the epoch lasts | 7 | unit: `a_vote_runs_a_window` |
-| 78 | A decision lowers a limit; a user signs on saying it saw nothing of the decision. Or a decision lowers a limit for a day, and raises it again. Or it sets a number that makes no sense | Valid as written, and resolved by the limit that holds: what is past it doesn't count. Names claimed in sight of what fell past it are their claimants' for good. The number has the result it has | 6; not promised | unit: `a_lowered_limit_leaves_out_the_last` |
-| 79 | Opens proposals without end | Refuse past `limits.proposals` | 6 | unit: `limits_on_proposals` |
-| 80 | A proposal gives away the name of a user that is out; the user is gone and another claims the name before it is decided | The claim was made in sight of one that didn't stand: it doesn't give way to what the decision gives | 5 | unit: `given_too_late` |
-| 81 | Contests a name, then asks the voters for it; or two claims of it are final | It takes two thirds of them; every other claim gives way to the one they name, final or not | not promised | unit: `whose_a_contested_name_is` |
-| 82 | Claims `wiki.r`, which the rules leave to the voters; holds on to it against a later decision | Refuse the claim. The name is whose the decision that holds says | 4, 7 | unit: `a_name_by_the_voters` |
-| 83 | A user is out and stays out: what of its names? | A decision frees them, or gives them to another, whatever `gone` says | 7 | unit: `a_decision_frees_or_gives` |
-| 84 | The voters decide a policy that covers a user's names no more; another user writes over what is uncovered; a third of the voters stamp to drop it at once | It doesn't count where the policy holds, and shows aside. Only its user takes it away, nobody changes it; it is dropped once seen there for `uncovered` | not promised | unit: `what_a_policy_no_longer_covers`, `uncovered_is_only_taken_away` |
-| 85 | The voters decide a policy that stops keeping names for their users | A kept name its user claimed stays its claim. One it didn't is the first comer's | not promised | unit: `a_kept_name_claimed` |
-| 86 | Names a base for a remake that leaves out what the swarm holds | No honest voter's node takes it up, unless records of it count for a third of the voters, an honest one among them | 7 | sim: `a_stale_base_is_not_taken_up` |
-| 87 | A remake's coordinator names two bases, each to one of two nodes of every voter | A record counts for a voter only where its vote names the record's base, and a voter signs one such vote an epoch: one base is decided, or none, and the coordinator shows | 7 | sim: `two_bases_one_remake` |
-| 88 | Runs most of the nodes; serves a snapshot of its own | Nothing reads a count of nodes; every node builds the snapshot itself | 7 | sim: `every_node_builds_the_snapshot` |
-| 89 | A name is claimed and settled after a remake's base; after the switch a pretender signs a claim of it "in the epoch before" | A root's node named the real claim in its carry record, before it took anything in the new epoch: the pretender's claim is late against it | 5 | unit: `a_carry_record_witnesses`; sim: `a_pretender_after_a_remake` |
-| 90 | Hands in, weeks into an epoch, envelopes of the epoch before that no node carried: a value its user since replaced, a statement its user never sent | Refuse what no carry record names. A node that holds such an envelope can still name it in its own record: then a value carried over has no word against one its user signed in the new epoch, and a claim is late against what a root's node's record named | 3 | unit: `only_what_a_carry_record_names`, `the_new_epoch_has_the_last_word` |
-| 91 | Signs after the switch, as of the epoch before, statements and a proposal with numbers of its choosing | Carried over comes after what the snapshot holds and before what the new epoch signs: such a number orders only its signer's statements among what is carried over, and the proposal outranks none of the new epoch | 6, 7 | unit: `carried_over_in_between` |
-| 92 | Writes a carry record naming what it likes, or several, or one of its own after taking from peers | One a node and epoch. What it names is its node's word, as a change of that node would have been: a contest where it is a root's or the claimant's, no more | 5 | unit: `one_carry_record_a_node` |
-| 93 | Unvouched a user, then has a node of its own stamp, weeks later, a change that has the user's claim and not the unvouch, to bring the claim back over one made in sight of it | Whether the claim stood is read where the later one was signed, with the witnesses there: one made after brings nothing back. A root's node doing so makes the two contest, in the open | 5 | unit: `a_witness_after_the_fact` |
-| 94 | Cuts its own device key off from before a user's creation it signed, to take the user's final name | The creation stops counting as its signer's unvouch would, from where the retirement was signed: what the user signed before counts, and its claim of its own name, with its own key, holds the name on. Without another vouch the user is out, its names waiting, final ones too, until it is gone or a vouch comes | 5 | unit: `a_users_own_name_by_its_own_key` |
-| 95 | Creates a user nobody else vouches for, lets it claim names until they are final, then cuts off the key it created it with from before the creation, to take the names | The creation stops counting as its signer's unvouch would, from where the retirement was signed: the user is out from there, its names wait, final ones and its own name too, and it is gone after `gone` unless a vouch comes. Nobody claims them meanwhile | 5 | unit: `a_creation_cut_off_puts_its_user_out` |
-| 96 | A root's node, beside a thief, commits with a fresh writer on heads without the retirement a change holding what the thief's sock signed, to keep it in past the cut | Past a cut only the signer's nodes witness, not a root's: the sock is out from where the retirement was signed, its names waiting until it is gone. An accomplice's vouch keeps it in | 5; not promised | unit: `a_cut_has_its_signers_witnesses` |
-| 97 | A node that held only the older of two values its user wrote since the base carries it beside the newer one | Of several carried over to one place, one that another replaces is left out | 3 | unit: `a_replaced_value_is_left_out` |
-| 98 | Signs a claim "in the epoch before" of a name the snapshot holds | It gives way to what the snapshot holds | 5 | unit: `the_snapshot_comes_first` |
-| 99 | Hands in again what a remake left out: a stolen laptop's `node` and `key` statements, retired since | Refuse: the root change lists the digests of the statements the base held | 3 | unit: `what_a_remake_dropped_stays_out` |
-| 100 | Keeps the last record of a remake back, and shows it a month later | Every node goes to that base. Its carry record names what it holds and what it held of it (who saw what first, decisions since), and each envelope comes once. A key rotated since keeps what its retirement lists. What a third of the voters' nodes held as gone, final or dropped stays so; other lengths start anew | not promised | sim: `a_remake_decided_late`; unit: `a_retirement_lists_what_it_keeps` |
-| 101 | Has voters vote for a second remake of an epoch, beside one that hangs | A voter signs one remake's vote an epoch, never released: two bases are both decided only where more than a third of the voters signed for both. No node that switched moves again by itself | 7 | sim: `one_remake_vote_an_epoch` |
-| 102 | A partition at the base: the nodes of a third of the voters take it up, the rest see it after they held more than it has | Every node takes up a base whose records count for a third of the voters, however old, and the remake is decided | 7 | sim: `a_base_seen_late` |
-| 103 | Proposes a remake beside another voter's; or hands its base first to nodes back from away, or one an hour old that such a node takes up, so that the nodes take up one base and no other | A node takes up every base that passes, one record a proposal. A client offers a vote only for a base whose records count for more than two thirds of the voters, which every node takes up, and shows the other remakes under way: a vote goes to a base every voter's node can take up. Only the votes keep two bases from both being decided | 7 | sim: `two_remakes_proposed_at_once` |
-| 104 | Proposes a twin of a remake under way, or as its coordinator names two bases to two nodes of each voter, so that honest votes split and the epoch's remakes end | Clients offer a vote for one of the remakes that name the same voters and roots (most votes, then the lowest digest), and none for a proposal whose coordinator named two bases. Honest voters signing within the same minutes can still be split | 7; not promised | sim: `a_twin_remake_gets_no_votes` |
-| 105 | Votes for a remake with the others, keeps its node's record back once they changed their minds, and shows it when it likes | Those who voted for the remake vote for no other in the epoch: it comes on the day its last record does. A node follows a remake at once only within `remakeAge` of taking its base up; past it, once the new epoch's carry records count for more than a third of the voters. Voters who split between two remakes end the epoch's remakes, and those left go apart | not promised | sim: `a_remake_held_by_its_last_record` |
-| 106 | Holds its node's record of a remake back, and shows it when some honest nodes are past `remakeAge` from taking the base up and some aren't | Those within it follow, those past it wait, and both sides see it. Once the new epoch's carry records count for more than a third of the voters every node follows; while they count for no more, `remakeAge` later, those that followed go back, their users' writes there quarantined to be signed again. Every honest node ends in one epoch; a remake shown long after its time is followed by the malicious alone | not promised; healed | sim: `a_remake_between_the_bounds_heals`, `a_remake_long_past_its_time` |
-| 107 | A thief's statements are in the base of a remake | They stand: a remake makes final. The vote's days are the time to cut the key off | not promised | unit: `a_cut_reaches_to_the_snapshot` |
-| 108 | Tells a node that was away of an epoch that isn't the swarm's | The node rejoins no epoch that peers advertise: it finishes the old one from archives and builds the next itself, or takes the ID its operator gave | 1 | sim: `away_over_a_remake`, `back_by_an_id` |
-| 109 | A node back after several remakes offers what its user signed epochs ago | Refuse: an envelope is taken in its epoch and the next. Quarantined, for the user to sign again | 3 | unit: `carried_over_one_epoch_only` |
-| 110 | A version builds another snapshot from a remake's base | Its node records another ID. The remake is decided for the ID two thirds got; the node stays, and says so | 7 | sim: `a_remake_by_its_result` |
-| 111 | A remake names its proposer the only root, or leaves a root out; the root left out signs on as one | The voters see whom a remake names before they vote for it. A root is one in the epoch that names it: what it signs after is an ordinary user's, and it is out unless someone vouches for it | 7 | unit: `roots_are_the_remakes`, `a_root_for_its_epoch` |
-| 112 | Two thirds of the voters turn on the rest | They remake, name the roots and who votes, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest refuse, or fork | not promised | argued (Going apart, Refusing a decision) |
-| 113 | Offers a statement signed on the other side of a fork | Refuse: it names its epoch | 3 | unit: `signed_for_its_user_id_and_epoch` |
-| 114 | A fork naming its proposer the only voter and root | A node follows only by its operator's word, which names the proposal; what that says shows | 7 | sim: `a_fork_by_choice` |
-| 115 | A decision breaks a node's bounds: the voters let one of them decide for all | The node refuses it and moves to the epoch built without it, the same for every node that refuses, with what it held: they go on together | 7 | unit: `bounds_on_the_numbers`; sim: `those_who_refuse_meet` |
-| 116 | Proposes saying it saw only the epoch's root, so that those who refuse carry the whole epoch over | No honest node takes up a proposal that says it saw less than the node held a window before: it isn't decided | 7 | unit: `a_proposal_says_it_saw_enough` |
-| 117 | Says it refuses a decision, or hands out the ID of an epoch without it, to draw nodes there | A node goes there by its own bounds or its operator's word only | 1 | unit: `refusing_is_ones_own` |
+| 65 | Forges a vote; votes as a user that isn't a voter, or one that is gone | Refuse | 7 | unit, decisions: `a_vote_is_a_voters` |
+| 66 | Brings in many users to vote, also while a remake's votes run | They vote only if a remake's list names them, which those who vote saw | 7 | unit: `who_votes` |
+| 67 | A remake's list of voters with the many users one user brought in; users put out between the votes and the base, to shrink the list | The voters see the list, by IDs, before they vote for it, and propose one of their own instead. Nothing after the proposal changes it | 7 | unit: `voters_are_the_remakes`, `a_list_is_fixed_when_signed` |
+| 68 | Records taking a proposal up without the votes, or with released ones | Refuse: every node judges a record against the votes in its history. A remake's record needs none: a remake is decided only by votes naming its base | 7 | unit: `a_record_needs_the_votes` |
+| 69 | Carries for many voters that have no node, and records with votes that ran out | Taken: nobody but the recording node reads a vote's end. A voter without a node is the party that carries for it, for a record; what is seen for long counts that node once | not promised | unit: `a_record_counts_for_its_voters`; argued (Decisions) |
+| 70 | Carries for a third of the voters, and keeps its records back: every decision waits, and comes on its day | The voters name another node, which records for them; their votes count meanwhile. A voter carried by nodes of two parties never waits for one. How many each node carries for shows | not promised | sim: `a_carrier_keeps_back` |
+| 71 | Keeps votes back until they ran out, or crafts them to look old, then shows them | No honest node takes the proposal up, and fewer than a third decide nothing. A remake's votes don't run out, and count when they come | 7 | unit: `taken_up_while_the_votes_run`; sim: `a_decision_from_the_past` |
+| 72 | Keeps its node's record back, and shows it weeks later: a proposal decided late | It holds only where none of its matter with a higher number was decided since: a node takes up nothing lower than it took up. What hangs shows, and the voters end it with a later proposal; not a remake's | not promised | unit: `nothing_lower_is_taken_up`; sim: `decided_late` |
+| 73 | Two proposals of one matter both decided: voters changed their minds, or a third voted both ways | Every node acts on the one with the higher number, the same from the same changes; the other shows as replaced | 7 | unit: `the_last_holds`; sim: `two_decided_one_holds` |
+| 74 | Makes a proposal saying it saw little or much, for a number of its choosing; grinds its digest; commits another's a second time | A number brings nothing without the votes of two thirds and their nodes' records; who votes is the epoch's, wherever a proposal is made; a second carrier changes nothing | 7 | unit: `a_proposal_is_where_it_was_signed` |
+| 75 | Stays away to hold decisions up | It counts on. A third staying away do hold them up: the rest go apart, naming who votes | 7 | unit: `two_thirds_of_all` |
+| 76 | Asks the voters for another user's first keys, saying it is that user | It takes two thirds of them, and the days a vote takes, shown to all; the user signs on meanwhile | not promised | argued (Decisions) |
+| 77 | Puts a voter's vote into a change of its own node; keeps one back; offers one again | Taken: the signature is the voter's. It counts while it runs; the register holds it once | 7 | unit: `a_vote_by_any_node` |
+| 78 | Signs a vote that says it runs out in ten years | A node counts no vote for longer than `window` from when it first held it; a remake's names its base and runs while the epoch lasts | 7 | unit: `a_vote_runs_a_window` |
+| 79 | A decision lowers a limit; a user signs on saying it saw nothing of the decision. Or a decision lowers a limit for a day, and raises it again. Or it sets a number that makes no sense | Valid as written, and resolved by the limit that holds: what is past it doesn't count. Names claimed in sight of what fell past it are their claimants' for good. The number has the result it has | 6; not promised | unit: `a_lowered_limit_leaves_out_the_last` |
+| 80 | Opens proposals without end | Refuse past `limits.proposals` | 6 | unit: `limits_on_proposals` |
+| 81 | A proposal gives away the name of a user that is out; the user is gone and another claims the name before it is decided | The claim was made in sight of one that didn't stand: it doesn't give way to what the decision gives | 5 | unit: `given_too_late` |
+| 82 | Contests a name, then asks the voters for it; or two claims of it are final | It takes two thirds of them; every other claim gives way to the one they name, final or not | not promised | unit: `whose_a_contested_name_is` |
+| 83 | Claims `wiki.r`, which the rules leave to the voters; holds on to it against a later decision | Refuse the claim. The name is whose the decision that holds says | 4, 7 | unit: `a_name_by_the_voters` |
+| 84 | A user is out and stays out: what of its names? | A decision frees them, or gives them to another, whatever `gone` says | 7 | unit: `a_decision_frees_or_gives` |
+| 85 | The voters decide a policy that covers a user's names no more; another user writes over what is uncovered; a third of the voters stamp to drop it at once | It doesn't count where the policy holds, and shows aside. Only its user takes it away, nobody changes it; it is dropped once seen there for `uncovered` | not promised | unit: `what_a_policy_no_longer_covers`, `uncovered_is_only_taken_away` |
+| 86 | The voters decide a policy that stops keeping names for their users | A kept name its user claimed stays its claim. One it didn't is the first comer's | not promised | unit: `a_kept_name_claimed` |
+| 87 | Names a base for a remake that leaves out what the swarm holds | No honest voter's node takes it up, unless records of it count for a third of the voters, an honest one among them | 7 | sim: `a_stale_base_is_not_taken_up` |
+| 88 | A remake's coordinator names two bases, each to one of two nodes of every voter | A record counts for a voter only where its vote names the record's base, and a voter signs one such vote an epoch: one base is decided, or none, and the coordinator shows | 7 | sim: `two_bases_one_remake` |
+| 89 | Runs most of the nodes; serves a snapshot of its own | Nothing reads a count of nodes; every node builds the snapshot itself | 7 | sim: `every_node_builds_the_snapshot` |
+| 90 | A name is claimed and settled after a remake's base; after the switch a pretender signs a claim of it "in the epoch before" | A root's node named the real claim in its carry record, before it took anything in the new epoch: the pretender's claim is late against it | 5 | unit: `a_carry_record_witnesses`; sim: `a_pretender_after_a_remake` |
+| 91 | Hands in, weeks into an epoch, envelopes of the epoch before that no node carried: a value its user since replaced, a statement its user never sent | Refuse what no carry record names. A node that holds such an envelope can still name it in its own record: then a value carried over has no word against one its user signed in the new epoch, and a claim is late against what a root's node's record named | 3 | unit: `only_what_a_carry_record_names`, `the_new_epoch_has_the_last_word` |
+| 92 | Signs after the switch, as of the epoch before, statements and a proposal with numbers of its choosing | Carried over comes after what the snapshot holds and before what the new epoch signs: such a number orders only its signer's statements among what is carried over, and the proposal outranks none of the new epoch | 6, 7 | unit: `carried_over_in_between` |
+| 93 | Writes a carry record naming what it likes, or several, or one of its own after taking from peers | One a node and epoch. What it names is its node's word, as a change of that node would have been: a contest where it is a root's or the claimant's, no more | 5 | unit: `one_carry_record_a_node` |
+| 94 | Unvouched a user, then has a node of its own stamp, weeks later, a change that has the user's claim and not the unvouch, to bring the claim back over one made in sight of it | Whether the claim stood is read where the later one was signed, with the witnesses there: one made after brings nothing back. A root's node doing so makes the two contest, in the open | 5 | unit: `a_witness_after_the_fact` |
+| 95 | Cuts its own device key off from before a user's creation it signed, to take the user's final name | The creation stops counting as its signer's unvouch would, from where the retirement was signed: what the user signed before counts, and its claim of its own name, with its own key, holds the name on. Without another vouch the user is out, its names waiting, final ones too, until it is gone or a vouch comes | 5 | unit: `a_users_own_name_by_its_own_key` |
+| 96 | Creates a user nobody else vouches for, lets it claim names until they are final, then cuts off the key it created it with from before the creation, to take the names | The creation stops counting as its signer's unvouch would, from where the retirement was signed: the user is out from there, its names wait, final ones and its own name too, and it is gone after `gone` unless a vouch comes. Nobody claims them meanwhile | 5 | unit: `a_creation_cut_off_puts_its_user_out` |
+| 97 | Creates a user, lets it settle names, then cuts the creation's key off from before it with a retirement that says it saw little, its own nodes silent, so that nothing the user signed counts through the creation, and an accomplice claims its names | The roots' nodes witness past a cut, as against an unvouch: what the user signed that a root's node had in its history counts, its settled names hold, and it is out from the retirement, its names waiting | 5 | unit: `a_cut_keeps_the_roots_witnesses` |
+| 98 | A root's node, beside a thief, commits with a fresh writer on heads without the retirement a change holding what the thief's sock signed, to keep it in past the cut | A root's node witnesses past a cut, as against an unvouch: the sock stays in by it, in the open, the root marked. An accomplice's vouch keeps it in too | not promised | unit: `a_cut_has_its_signers_witnesses` |
+| 99 | A node that held only the older of two values its user wrote since the base carries it beside the newer one | Of several carried over to one place, one that another replaces is left out | 3 | unit: `a_replaced_value_is_left_out` |
+| 100 | Signs a claim "in the epoch before" of a name the snapshot holds | It gives way to what the snapshot holds | 5 | unit: `the_snapshot_comes_first` |
+| 101 | Hands in again what a remake left out: a stolen laptop's `node` and `key` statements, retired since | Refuse: the root change lists the digests of the statements the base held | 3 | unit: `what_a_remake_dropped_stays_out` |
+| 102 | Keeps the last record of a remake back, and shows it a month later | Every node goes to that base. Its carry record names what it holds and what it held of it (who saw what first, decisions since), and each envelope comes once. A key rotated since keeps what its retirement lists. What a third of the voters' nodes held as gone, final or dropped stays so; other lengths start anew | not promised | sim: `a_remake_decided_late`; unit: `a_retirement_lists_what_it_keeps` |
+| 103 | Has voters vote for a second remake of an epoch, beside one that hangs | A voter signs one remake's vote an epoch, never released: two bases are both decided only where more than a third of the voters signed for both. No node that switched moves again by itself | 7 | sim: `one_remake_vote_an_epoch` |
+| 104 | A partition at the base: the nodes of a third of the voters take it up, the rest see it after they held more than it has | Every node takes up a base whose records count for a third of the voters, however old, and the remake is decided | 7 | sim: `a_base_seen_late` |
+| 105 | Proposes a remake beside another voter's; or hands its base first to nodes back from away, or one an hour old that such a node takes up, so that the nodes take up one base and no other | A node takes up every base that passes, one record a proposal. A client offers a vote only for a base whose records count for more than two thirds of the voters, which every node takes up, and shows the other remakes under way: a vote goes to a base every voter's node can take up. Only the votes keep two bases from both being decided | 7 | sim: `two_remakes_proposed_at_once` |
+| 106 | Proposes a twin of a remake under way, or as its coordinator names two bases to two nodes of each voter, so that honest votes split and the epoch's remakes end | Clients offer a vote for one of the remakes that name the same voters and roots (most votes, then the lowest digest), and none for a proposal whose coordinator named two bases. Honest voters signing within the same minutes can still be split | 7; not promised | sim: `a_twin_remake_gets_no_votes` |
+| 107 | Votes for a remake with the others, keeps its node's record back once they changed their minds, and shows it when it likes | Those who voted for the remake vote for no other in the epoch: it comes on the day its last record does. A node follows a remake at once only within `remakeAge` of taking its base up; past it, once the new epoch's carry records count for more than a third of the voters. Voters who split between two remakes end the epoch's remakes, and those left go apart | not promised | sim: `a_remake_held_by_its_last_record` |
+| 108 | Holds its node's record of a remake back, and shows it when some honest nodes are past `remakeAge` from taking the base up and some aren't | Those within it follow, those past it wait, and both sides see it. Once the new epoch's carry records count for more than a third of the voters every node that waits follows; until then those that followed stay, or go back by their operators' word, their users' writes there quarantined to be signed again. A remake shown long after its time is followed by the malicious alone | not promised; healed | sim: `a_remake_between_the_bounds_heals`, `a_remake_long_past_its_time` |
+| 109 | Holds its own carry records back, or takes them back by stopping its node with a cut, or carries for honest voters without nodes, to steer whether a split heals forward or back, and when | The heal counts a node for one voter, each record as it stood where written; nobody goes back but by its operator's word. The malicious choose when a split starts, not whether the honest follow nor that they go back and forth | not promised; 7 | sim: `a_heal_the_malicious_cant_steer` |
+| 110 | A thief's statements are in the base of a remake | They stand: a remake makes final. The vote's days are the time to cut the key off | not promised | unit: `a_cut_reaches_to_the_snapshot` |
+| 111 | Tells a node that was away of an epoch that isn't the swarm's | The node rejoins no epoch that peers advertise: it finishes the old one from archives and builds the next itself, or takes the ID its operator gave | 1 | sim: `away_over_a_remake`, `back_by_an_id` |
+| 112 | A node back after several remakes offers what its user signed epochs ago | Refuse: an envelope is taken in its epoch and the next. Quarantined, for the user to sign again | 3 | unit: `carried_over_one_epoch_only` |
+| 113 | A version builds another snapshot from a remake's base | Its node records another ID. The remake is decided for the ID two thirds got; the node stays, and says so | 7 | sim: `a_remake_by_its_result` |
+| 114 | A remake names its proposer the only root, or leaves a root out; the root left out signs on as one | The voters see whom a remake names before they vote for it. A root is one in the epoch that names it: what it signs after is an ordinary user's, and it is out unless someone vouches for it | 7 | unit: `roots_are_the_remakes`, `a_root_for_its_epoch` |
+| 115 | Two thirds of the voters turn on the rest | They remake, name the roots and who votes, set any number (a share of the voters that lets one decide for all), change the policy, give a user's first keys to another, deal with the names of a user that is out, and say whose a contested name is: a name taken, in the open. They forge no signature and move nobody to other rules; the rest refuse, or fork | not promised | argued (Going apart, Refusing a decision) |
+| 116 | Offers a statement signed on the other side of a fork | Refuse: it names its epoch | 3 | unit: `signed_for_its_user_id_and_epoch` |
+| 117 | A fork naming its proposer the only voter and root | A node follows only by its operator's word, which names the proposal; what that says shows | 7 | sim: `a_fork_by_choice` |
+| 118 | A decision breaks a node's bounds: the voters let one of them decide for all | The node refuses it and moves to the epoch built without it, the same for every node that refuses, with what it held: they go on together | 7 | unit: `bounds_on_the_numbers`; sim: `those_who_refuse_meet` |
+| 119 | Proposes saying it saw only the epoch's root, so that those who refuse carry the whole epoch over | No honest node takes up a proposal that says it saw less than the node held a window before: it isn't decided | 7 | unit: `a_proposal_says_it_saw_enough` |
+| 120 | Says it refuses a decision, or hands out the ID of an epoch without it, to draw nodes there | A node goes there by its own bounds or its operator's word only | 1 | unit: `refusing_is_ones_own` |
Nodes and syncing:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 118 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` |
-| 119 | Forks its node's actor | The nodes that took each split; one offered both holds proof and refuses the node; a side drops by its operator's choice | not promised | sim: `a_forked_actor_is_proven`, `a_side_drops_a_fork` |
-| 120 | Holds changes back, or passes on some | They come by other nodes; a joiner caught up with it syncs on | 6 | sim: `withheld_changes_arrive` |
-| 121 | Places its nodes around a victim by choosing their keys | The victim's node keeps its seeds and its user's other nodes as neighbours; a claim not settled for long shows. It costs time, not names | 5, 6 | sim: `around_a_victim` |
-| 122 | Hands a joining node another root change, or changes from before the policy | Refuse the handshake; there is no before | 1 | sim: `a_joiner_takes_its_root_only` |
-| 123 | Signs a token for any user with its node's key | Taken only by a node whose operator named the signing node | 3 | unit: `a_token_of_ones_party` |
-| 124 | Logs in on another party's node with a key of the registry; has a name in the registry that the node's own users have | Keys in the registry give nothing on anyone's node by themselves: whom a node lets in is its operator's, and what a user may write is in its signature | 3 | unit: `registry_keys_open_no_node` |
-| 125 | Lies in its member entry (ready, reached, stable); publishes a short window there to make every node stamp hourly; writes an entry of any size | Sync and trees bend; nothing gets in that way. How often nodes stamp is the policy's; an entry has a shape and a size, or the change is refused | 6 | unit: `an_entry_has_a_shape`, `stamps_by_the_policy`; argued (Reaching the others) |
-| 126 | Sends envelopes that don't check, without end | Refuse each (a signature costs about 30 µs to check *(docs)*); the node is refused as a whole after the first of its own | 6 | sim: `a_refused_node_costs_little` |
-| 127 | Writes its own member entry without end; signs and gives up without end; fills the waiting changes; sends changes that say they saw little, each to be judged far back | Take them no faster than a budget per party: put off, never refused; a share of the waiting each | 6 | sim: `a_party_past_its_budget_waits` |
-| 128 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a user and epoch, every node puts off the changes that start more of the nodes whose writers count for it: a node's, for the user its member entry names. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out. A user below a root costs the root nothing, and one beside others on a node costs them nothing, but where the node's entry names it | 6; not bounded | sim: `writers_past_their_limit_wait` |
-| 129 | One of the users a node carries for, besides the node's own, starts writers past its limit, from nodes of its own | The node's writers count for the user its member entry names, over a remake too, and nothing of it is put off for the others: the users beside it write on | 6 | sim: `writers_count_for_a_nodes_first_user` |
-| 130 | Signs its `node` statement naming another party's node again and again until its digest is the lowest, so that the node's writers count for it after a remake, then starts writers past its limit | A node's writers count for the user its member entry names, the node's own word, carried over a remake; the digest decides only where the entry names none | 6 | unit: `writers_count_for_the_user_an_entry_names` |
-| 131 | Sends a node a change of the node's own writer, another value, to make it start a writer | Refused as forged; the node switches only where its own key signed it (a copy of its files) | 6 | unit, exists: `another_writing_as_this_node` |
-| 132 | Crafts a first change of another node's writer, authored as a third node, to sort before the writer's own in a batch, so that screening judges the writer's changes as the third node's | Screening names a change's node by its own author, or that of its actor's first change in its own history, never by another change of the batch: the writer's changes are vouched for by their own node's signature, and the crafted one, a second first change of the writer, is refused as forged | 1, 2 | unit, exists: `a_committer_from_its_own_history` |
-| 133 | Sends a change of a few bytes that holds a million operations | Taken, at the cost of applying it: nothing bounds a change's operations | not promised (a bound on what an epoch's document costs) | argued |
-| 134 | Crafts a change Automerge won't take, or that writes in an object nowhere to be found | Refuse *(checked: the rules refuse the second today)*; only the message that brought it fails | 1 | unit: `a_change_writing_nowhere` |
-| 135 | Crafts a change Automerge takes and shouldn't: bytes it wouldn't encode itself, operations numbered against its dependencies', a gap in its actor's changes, an operation named that is elsewhere or outside its history, an operation Automerge's transactions never write (an element written over naming the one inserted after it, an insert that replaces, a deletion or an increment inserted, a deletion named as replaced), a table written into, a value written at a mark's begin | Refuse before Automerge sees it, by the change and its own history alone: applied, such a change makes a node panic, save a document that doesn't load, or part from nodes it reached in another order | 1, 2 | unit, exist: `bytes_automerge_wouldnt_encode_are_refused`, `operations_numbered_against_their_dependencies_are_refused`, `a_gap_in_an_actors_changes_is_refused`, `operations_named_at_the_wrong_place_are_refused`, `operations_outside_a_changes_history_are_refused`, `only_what_transactions_write_passes`, `only_what_holds_a_value_is_replaced`, `no_table`, `no_mark`, `what_passes_leaves_automerge_sound`, `a_batch_is_checked_against_itself`, `a_change_refused_after_its_check_stands_in_for_nothing` |
+| 121 | Sends different changes to different peers, each under its own number | Take all: changes made at once | 2 | sim: `two_histories_merge` |
+| 122 | Forks its node's actor | The nodes that took each split; one offered both holds proof and refuses the node; a side drops by its operator's choice | not promised | sim: `a_forked_actor_is_proven`, `a_side_drops_a_fork` |
+| 123 | Holds changes back, or passes on some | They come by other nodes; a joiner caught up with it syncs on | 6 | sim: `withheld_changes_arrive` |
+| 124 | Places its nodes around a victim by choosing their keys | The victim's node keeps its seeds and its user's other nodes as neighbours; a claim not settled for long shows. It costs time, not names | 5, 6 | sim: `around_a_victim` |
+| 125 | Hands a joining node another root change, or changes from before the policy | Refuse the handshake; there is no before | 1 | sim: `a_joiner_takes_its_root_only` |
+| 126 | Signs a token for any user with its node's key | Taken only by a node whose operator named the signing node | 3 | unit: `a_token_of_ones_party` |
+| 127 | Logs in on another party's node with a key of the registry; has a name in the registry that the node's own users have | Keys in the registry give nothing on anyone's node by themselves: whom a node lets in is its operator's, and what a user may write is in its signature | 3 | unit: `registry_keys_open_no_node` |
+| 128 | Lies in its member entry (ready, reached, stable); publishes a short window there to make every node stamp hourly; writes an entry of any size | Sync and trees bend; nothing gets in that way. How often nodes stamp is the policy's; an entry has a shape and a size, or the change is refused | 6 | unit: `an_entry_has_a_shape`, `stamps_by_the_policy`; argued (Reaching the others) |
+| 129 | Sends envelopes that don't check, without end | Refuse each (a signature costs about 30 µs to check *(docs)*); the node is refused as a whole after the first of its own | 6 | sim: `a_refused_node_costs_little` |
+| 130 | Writes its own member entry without end; signs and gives up without end; fills the waiting changes; sends changes that say they saw little, each to be judged far back | Take them no faster than a budget per party: put off, never refused; a share of the waiting each | 6 | sim: `a_party_past_its_budget_waits` |
+| 131 | Starts a writer with every change: each costs every node memory in proportion to the document's history | Past `limits.writers` a user and epoch, every node puts off the changes that start more of the nodes whose writers count for it: a node's, for the user its member entry names. Nothing is refused; what reaches a node within others' histories is held, and a remake leaves it out. A user below a root costs the root nothing, and one beside others on a node costs them nothing, but where the node's entry names it | 6; not bounded | sim: `writers_past_their_limit_wait` |
+| 132 | One of the users a node carries for, besides the node's own, starts writers past its limit, from nodes of its own | The node's writers count for the user its member entry names, over a remake too, and nothing of it is put off for the others: the users beside it write on | 6 | sim: `writers_count_for_the_user_an_entry_names_beside_others` |
+| 133 | Signs its `node` statement naming another party's node again and again until its digest is the lowest, so that the node's writers count for it after a remake, then starts writers past its limit | A node's writers count for the user its member entry names, the node's own word, carried over a remake; the digest decides only where the entry names none | 6 | unit: `writers_count_for_the_user_an_entry_names` |
+| 134 | Sends a node a change of the node's own writer, another value, to make it start a writer | Refused as forged; the node switches only where its own key signed it (a copy of its files) | 6 | unit, exists: `another_writing_as_this_node` |
+| 135 | Crafts a first change of another node's writer, authored as a third node, to sort before the writer's own in a batch, so that screening judges the writer's changes as the third node's | Screening names a change's node by its own author, or that of its actor's first change in its own history, never by another change of the batch: the writer's changes are vouched for by their own node's signature, and the crafted one, a second first change of the writer, is refused as forged | 1, 2 | unit, exists: `a_committer_from_its_own_history` |
+| 136 | Sends a change of a few bytes that holds a million operations | Taken, at the cost of applying it: nothing bounds a change's operations | not promised (a bound on what an epoch's document costs) | argued |
+| 137 | Crafts a change Automerge won't take, or that writes in an object nowhere to be found | Refuse *(checked: the rules refuse the second today)*; only the message that brought it fails | 1 | unit: `a_change_writing_nowhere` |
+| 138 | Crafts a change Automerge takes and shouldn't: bytes it wouldn't encode itself, operations numbered against its dependencies', a gap in its actor's changes, an operation named that is elsewhere or outside its history, an operation Automerge's transactions never write (an element written over naming the one inserted after it, an insert that replaces, a deletion or an increment inserted, a deletion named as replaced), a table written into, a value written at a mark's begin | Refuse before Automerge sees it, by the change and its own history alone: applied, such a change makes a node panic, save a document that doesn't load, or part from nodes it reached in another order | 1, 2 | unit, exist: `bytes_automerge_wouldnt_encode_are_refused`, `operations_numbered_against_their_dependencies_are_refused`, `a_gap_in_an_actors_changes_is_refused`, `operations_named_at_the_wrong_place_are_refused`, `operations_outside_a_changes_history_are_refused`, `only_what_transactions_write_passes`, `only_what_holds_a_value_is_replaced`, `no_table`, `no_mark`, `what_passes_leaves_automerge_sound`, `a_batch_is_checked_against_itself`, `a_change_refused_after_its_check_stands_in_for_nothing` |
Rules, and the swarm as it is:
| # | The adversary | Honest nodes | Promise | Shown by |
|---|---|---|---|---|
-| 136 | A rule differs between versions (a bug) | Each side refuses what the other takes, or their stamps name two digests for the same changes: each logs and shows it. A node that finds itself apart from the nodes of more than two thirds of the other voters at its first start with a version writes nothing. One side upgrades and drops | not promised | sim: `a_side_drops_and_comes_back`, `two_digests_one_history`; unit: `a_node_checks_itself` |
-| 137 | Stamps a wrong digest, to keep the nodes that upgrade from writing; one of three voters does | A node stops only where it differs from the nodes of more than two thirds of the other voters; from fewer it shows it and goes on | 6 | unit: `one_wrong_digest_stops_nobody`, `of_three_voters` |
-| 138 | A policy version a node doesn't know: in the root, or decided | It doesn't sync, and takes no such proposal up: a policy is decided only with two thirds of the voters' nodes knowing it | 1 | unit: `no_sync_under_an_unknown_policy`, `an_unknown_policy_isnt_taken_up` |
-| 139 | A partition, for any length of time | A side decides only with nodes of two thirds of all the voters on it. Where a third of them have nodes and votes on both sides, both may: every node then acts on the higher number | 7 | sim: `one_side_decides`; unit: `the_last_holds` |
-| 140 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` |
+| 139 | A rule differs between versions (a bug) | Each side refuses what the other takes, or their stamps name two digests for the same changes: each logs and shows it. A node that finds itself apart from the nodes of more than two thirds of the other voters at its first start with a version writes nothing. One side upgrades and drops | not promised | sim: `a_side_drops_and_comes_back`, `two_digests_one_history`; unit: `a_node_checks_itself` |
+| 140 | Stamps a wrong digest, to keep the nodes that upgrade from writing; one of three voters does | A node stops only where it differs from the nodes of more than two thirds of the other voters; from fewer it shows it and goes on | 6 | unit: `one_wrong_digest_stops_nobody`, `of_three_voters` |
+| 141 | A policy version a node doesn't know: in the root, or decided | It doesn't sync, and takes no such proposal up: a policy is decided only with two thirds of the voters' nodes knowing it | 1 | unit: `no_sync_under_an_unknown_policy`, `an_unknown_policy_isnt_taken_up` |
+| 142 | A partition, for any length of time | A side decides only with nodes of two thirds of all the voters on it. Where a third of them have nodes and votes on both sides, both may: every node then acts on the higher number | 7 | sim: `one_side_decides`; unit: `the_last_holds` |
+| 143 | None: a swarm that isn't federated | Everything as today | Optional | the existing tests, untouched; `bench_screening` |
## The registry on it
```
@@ -2274,7 +2294,7 @@ it trusts for that.
## Stages
Each leaves the system working, and is a few patches with its tests, which leave
-their vectors. At every stage the existing tests pass untouched (140).
+their vectors. At every stage the existing tests pass untouched (143).
1. **A federated swarm's frame.** `--genesis-policy` (a file, written into the genesis
change with the roots, the voters and the users it starts with); a federated node
@@ -2282,7 +2302,7 @@ their vectors. At every stage the existing tests pass untouched (140).
yet, takes tokens and logins by key as its operator says, keeps ended sessions to
itself, stamps as the policy says, and writes a member entry of the policy's shape
and size. What the genesis change sets for the swarm as a whole is read from the
- policy. Tests: 122 to 125, 132, 135, 138, 140, and the policy's existing tests
+ policy. Tests: 125 to 128, 135, 138, 141, 143, and the policy's existing tests
under a policy from the genesis change. Those of a crafted change, and of a crafted
committer, exist already: screening refuses those in every swarm.
2. **Statements.** The users' registers (`create`, `key`, `node`, `vouch`, `release`);
@@ -2291,33 +2311,33 @@ their vectors. At every stage the existing tests pass untouched (140).
limits, and the order past them. First, the payloads: each statement's fields and
the member entry's shape, settled, so that tests leave vectors. Resolving, step 2
without cuts, and `GET /registry/users`. The client signs statements. Tests: 1 to
- 10, 14, 15, 18, 31.
-3. **Namespaces.** The rule, with `userSigned` below a name. Tests: 30, 32. From here
+ 11, 15, 16, 19, 32.
+3. **Namespaces.** The rule, with `userSigned` below a name. Tests: 31, 33. From here
the registry runs with users and hosts, names not yet unique.
4. **Claims in sight.** Kinds, names as they are written, their characters, rules by
their structure, kept names and claims of them, limits, `claim` and `release`,
judged as written; resolving step 4 for claims in sight, and what comes back.
- Tests: 16, 34, 37 to 39.
+ Tests: 17, 35, 38 to 40.
5. **Out of sight.** Late, contested and settled, for names and for users' names; a
claim's side; a root's node writing when a claim reaches it, and a node that comes
back catching up first. The voters as the root change names them; lengths of time
read from the stamps; final. `GET /registry/claims` with what makes a claim late;
values marked in `GET /store`. A node keeps its seeds and its user's other nodes as
neighbours, leaves out members that name another epoch, and shows a claim long
- unsettled. Tests: 12, 13, 27, 33, 35, 36, 40 to 43, 46, 49, 50, 118, 120, 121.
+ unsettled. Tests: 13, 14, 28, 34, 36, 37, 41 to 44, 47, 50, 51, 121, 123, 124.
6. **Cuts.** `retire` and the keys above, a node that stops, a cut never reaching its
own statement, what a cut takes back, what doesn't count left out, the value before
- read again, the client listing what stopped counting. Tests: 11, 17, 44, 45, 48, 51
- to 55, 62, 63.
+ read again, the client listing what stopped counting. Tests: 12, 18, 45, 46, 49, 52
+ to 56, 63, 64.
7. **Unvouching.** `unvouch`, a vouch or a creation cut off as by an unvouch, a user
giving itself up, one that another vouched for staying, those brought in going with
it, the names of a user that is out waiting, gone, nothing taken from an unvouched
- user's nodes, what comes back with a vouch. Tests: 19, 21 to 26, 28, 29, 56 to 59,
- 61, 93 to 96.
+ user's nodes, what comes back with a vouch. Tests: 20, 22 to 27, 29, 30, 57 to 60,
+ 62, 94 to 98.
8. **Coming back.** The drop an operator asks for, a forked actor proven and shown
with what the roots' nodes hold, the budget and the share per party, the writers
counted per user, for the one a node's member entry names, a node keeping its
- writer over a clean stop. Tests: 119, 126 to 131, 133, 134.
+ writer over a clean stop. Tests: 122, 129 to 134, 136, 137.
9. **The registry.** Import, export, and a federated swarm of the simulations with the
registry's kinds and a few hundred hosts. From here it can be tried: users, hosts,
names, a root that settles, names that become final. It isn't to be relied on yet.
@@ -2329,10 +2349,10 @@ their vectors. At every stage the existing tests pass untouched (140).
holds, what hangs; `GET /registry/decisions`. What is decided: a number, a user's
first keys, the names of a user that is out, whose a contested name is, a name the
rules leave to the voters. The simulations start from a root change naming several
- voters, as a remake's does. Tests: 20, 47, 60, 64, 67 to 83, 139.
+ voters, as a remake's does. Tests: 21, 48, 61, 65, 68 to 84, 142.
11. **Versions.** The digest with every stamp, a node checking itself before it
writes; for every swarm, a node that speaks the wire version before its own, and a
- handshake that says which epochs its node keeps. Tests: 136, 137.
+ handshake that says which epochs its node keeps. Tests: 139, 140.
12. **Remakes.** The proposal with its list of voters, its roots and its coordinator;
the base, every one a node finds holding what it held `baseAge` before, however
old where records count for a third, one record a proposal, judged without votes;
@@ -2343,15 +2363,15 @@ their vectors. At every stage the existing tests pass untouched (140).
word last on values; a retirement's list as its cut; decisions and what was seen
for long, over a remake; what becomes final. A node keeping the epochs it left on
disk, peers answering for them and saying which; a node walking them, or rejoining
- by an ID its operator gave, and by none that peers advertise. Tests: 65, 66, 86 to
- 92, 97 to 104, 107 to 111.
+ by an ID its operator gave, and by none that peers advertise. Tests: 66, 67, 87 to
+ 93, 99 to 106, 110 to 114.
13. **The policy by a decision.** The policy as a matter, a node that doesn't know it,
what it no longer covers: shown aside, taken away by its user only, dropped after
- a time, moved at a remake. Tests: 84, 85, 138.
+ a time, moved at a remake. Tests: 85, 86, 141.
14. **Going apart, and refusing.** A fork followed by an operator's word, with who
votes and who the roots are on its side. Refusing a decision: a node's bounds, how
late a remake it follows at once (`remakeAge`) and how the split heals, the epoch
- without the decision, what a node takes along. Tests: 105, 106, 112 to 117. From
+ without the decision, what a node takes along. Tests: 107 to 109, 115 to 120. From
here it can be relied on: the rules change by decisions.
## What was checked, and what is assumed
@@ -2468,6 +2488,7 @@ Assumed, to be shown as it is built:
size.
* A node counts the writers each user's nodes started in the epoch as it takes their
changes, cheaply enough: a count kept per user.
-* What is asked of a change before Automerge sees it keeps out every change
- it applies and shouldn't. Crafted changes were tried by hand against Automerge
- alone; no fuzzer was run over them.
+* What is asked of a change before Automerge sees it keeps out every change it applies
+ and shouldn't. Changes are generated against it
+ (`what_passes_leaves_automerge_sound`); batches, changes on older states and chunk
+ bytes only outside continuum so far.