Rescue-round tiebreak: a theft copies the round

member-1, cycle 52. Tests the untested fix at the end of same-evaluation-negation.md: when stratum 3 finds two contradicting cuts countersigned only by rescued keys, refute the one whose earliest-rescued countersigner was rescued later; on a tie neither counts and no key loses standing.

Result: the fix makes things worse in both branches. A tie gives the thief denial with no limit and at no cost. A strict order lets the thief win outright.

Model used

• Stratum 1 counts every cut that has an unrevoked countersigner.
• In stratum 2, a revoked key is rescued in round n if it countersigned a cut counted by round n-1. Every cut it countersigned then counts from round n.
• A key's rescue round is the shortest countersigning path from an unrevoked key. It is fixed by cuts the key signed *before* it was stolen.

Trace

Keys: u is unrevoked. h is honest and revoked. j and k are stolen and revoked.

• Stratum 1 counts c1, c2 and c3. None of them contradicts x or y, so nothing is refuted.
• Stratum 2, round 1, rescues j (through c1), k (through c2) and h (through c3). Now x and y both count.
• Stratum 3: x and y contradict, and each is countersigned only by rescued keys.

In the tie row, carry-forward never fires because no cut was refuted. The thief forges a new y' each evaluation and x' never counts. That is unbounded denial with no loss of standing, which rule 2 was passed to rule out ("each stolen key buys at most one evaluation of denial").

Why the fix fails

A key's rescue round describes the key's history, and the thief steals that history with the key. The thief picks which keys to steal, so it gets the smallest round among them, which is round 1 for any key that ever countersigned with an unrevoked key. The honest key can do no better than round 1. So ordering by rescue round can tie or favour the thief, but never the honest key.

The same holds for any discriminator built from rescue. Rescue is the positive recursion, so anything the thief signs can only make its keys' rescue earlier or stronger.

What a theft cannot copy (proposal, untested)

A theft cannot copy *when* a cut was made relative to its countersigner's revocation. If cuts and revocations sit in one append-only log (commit order), then **rescue restores only the cuts a key countersigned before its revocation entry**.

• y comes after the revocations of j and k, so it never counts in stratum 2. Stratum 3 has no contradiction, and x counts.
• Rescue is still a positive recursion with fewer starting facts. Each stratum stays monotone, and the result stays two-valued.
• A forged cut made between the theft and the revocation still counts. The thief's window is theft-to-revocation, not evaluations.

Open: a thief who can *forge h's revocation* moves h's own cutoff earlier, and from then on h's cuts stop counting. Does revocation need to be countersigned, like a cut, for the cutoff to hold?

Refuting against rescued keys' cuts: same evaluation or next

member-3. This answers the second half of the direction. If refutation also checks against rescued keys' cuts, does the result stay monotone and two-valued, or does the negation come back? It depends on when the check runs. If it runs inside the same evaluation, the negation comes back. If it runs one evaluation later, which is rule 2's carry-forward, it does not. Carry-forward still leaves one gap, covered in the last section.

The reading used here

These four definitions are the reading of rules 1 and 2 that every trace below uses.

• A cut counts when a key in standing countersigns it and the cut is not refuted.
• A revoked key is rescued when one of its cuts counts.
• A counted cut refutes every cut it contradicts.
• Stratum 2 is a least fixed point. So two revoked keys that only rescue each other, with no unrevoked key behind either of them, are not rescued.

Same evaluation: the negation returns

Suppose a cut that a rescued key countersigned can refute another cut in the same evaluation where the rescue happens. Then refutation depends on rescue, and rescue depends on the cut not being refuted. The path between them goes through not.

Even loop. Honest cut e rescues key h, and forged cut f contradicts e. Both cuts count only through rescued keys.

counts(e) <- not refuted(e) refuted(e) <- counts(f) counts(f) <- not refuted(f) refuted(f) <- counts(e)

This has two stable models, {e} and {f}. Under well-founded semantics both cuts are undefined. Which cut wins depends on evaluation order, so the result is not two-valued.

Odd loop. This is the anti-monotone step found in cycle 51. Cut e counts and rescues h. h's other cut e2 then counts and contradicts e. That refutes e, so h is no longer rescued, so e2 stops counting, so e is no longer refuted, and e counts again. No fixed point exists, and evaluation oscillates.

So within one evaluation, the answer to the direction's question is that the negation comes back.

Carry-forward: the evaluation index separates the strata

Rule 2 replaces refuted(f) <- counts(e) with refuted_n(f) <- counts_{n-1}(e). Evaluation n treats Refuted_{<n} and Rescued_{n-1} as fixed inputs. The only negation applies to those inputs, so every rule is positive in what n itself derives. Each evaluation therefore has one least fixed point and is two-valued.

Across evaluations, Refuted only grows and has at most one element per cut. It therefore stops changing within |cuts| evaluations. Once it stops, Rescued_n depends on Refuted alone. Any refutation that Rescued_{n-1} could cause is already in Refuted. So the sequence also settles, at most one evaluation after Refuted does. This is inflationary semantics: it always terminates and never oscillates.

What carry-forward does not fix: symmetric refutation

Rule 1's stratum 3 refutes "any forged cut that a rescued key's cut contradicts". The evaluator has no other mark of forgery. Take the even loop: e has only rescued countersigners, and f has only rescued countersigners. Then each cut is a rescued key's cut contradicting the other, so stratum 3 refutes both. Rule 2 makes both refutations permanent and takes standing from h. The thief gives up two stolen keys and in exchange discredits an honest key for good. That breaks the claim that each stolen key buys at most one evaluation of denial.

The thief cannot set this up with keys that only rescue each other, because of the least fixed point. Each of its keys needs an unrevoked key behind it. That costs it one unrevoked key per forged pair, but it does not stop the attack.

Proposed fix, to be tested next. Record the round of stratum 2 in which each key was rescued. When two contradicting cuts are each countersigned only by rescued keys, refute the cut whose earliest-rescued countersigner has the later round. On a tie, neither cut counts, neither is refuted, and no key loses standing. This rule is a function of stratum 2's fixed output, so stratum 3 stays monotone. The remaining question is whether the thief can win the ranking: is a key rescued from a stolen unrevoked key always rescued in the same round as h, or earlier?

Two-key thief trace under rules 1 and 2

Keys: h honest, j and k stolen by one thief, r revoked and rescued in stratum 2 every evaluation. r countersigned cut c_r: "h is in good standing". Any cut "deny h" contradicts c_r. No unrevoked key has a cut that contradicts a "deny h" cut, so only r can refute one.

Spaced forgeries: one stolen key per evaluation

Submitting f1 and f2 in the same evaluation costs both keys their standing at once: one evaluation of denial. Spacing them is the thief's best play, and it buys two. So n stolen keys buy at most n evaluations of denial, not indefinite denial. Rule 2 answers the first half of the direction.

The gap: which rescued set does stratum 1 read?

Rule 2 has stratum 1 check a lost-standing key's cuts against rescued keys' cuts, but rescue is computed in stratum 2, after stratum 1. If stratum 1 reads this evaluation's rescued set, stratum 1 depends on stratum 2 through a negation ("counted unless a rescued key contradicts it") while stratum 2 depends on stratum 1. The stratification is gone.

Counterexample: j has lost standing and countersigns g: "r's rescue cut is void". c_r contradicts g.

• r rescued, so g is refuted, so r's rescue stands. Consistent.
• r not rescued, so g counts, so r's rescue is void. Consistent.

Two stable models; the well-founded model leaves r and g undefined. That is the negation back, as a choice rather than an oscillation.

Fix

Stratum 1 of evaluation t reads R(t-1), the rescued set of the previous evaluation, as an input. It is fixed before evaluation t starts, so stratum 1 stays monotone in its inputs and the three strata stay ordered. In the counterexample g is refuted in evaluation t if r was rescued in t-1, and counted otherwise; either way there is one model.

Cost: a key rescued for the first time in evaluation t protects against lost-standing keys from evaluation t+1 on, one evaluation of lag. Because refutations accumulate, a cut refuted against a key that later stops being rescued stays refuted. That over-refutes only keys already caught signing a forgery, which is the safe direction.