oxedyne/ore/oracle/PREDICTIONS_cycle_rule.md
6.6 KiB, 1 run
created by r2848102244:49, which is this file's identity for as long as the history lasts, whatever it is later renamed to
download · who wrote it · its history
| 1 | # Cross-file cycle rule: predictions, written before the engine was changed |
| 2 | |
| 3 | Recorded 12026-07-28, before a line of `CycleRule` was written and before any of |
| 4 | these cases was run. Traced by hand through the split points, the claim register |
| 5 | and the in-order traversal. Anything below that the oracle contradicts is a |
| 6 | finding, not a typo, and is to be reported as a disagreement rather than quietly |
| 7 | corrected. |
| 8 | |
| 9 | Rules, as they will be spelled in `repo.rs`: |
| 10 | |
| 11 | - `Demote` -- D, the status quo of `sequence_with_move.md` §5.4. |
| 12 | - `ConfineVictim` -- A as the brief phrases it: the *demotion victim*, and only |
| 13 | it, is confined to its source position when demoting would land its content in |
| 14 | another file. |
| 15 | - `ConfineCycle` -- A read as a property of the cycle rather than of the |
| 16 | demotion: **every** cross-file member of the cycle is confined to its source. |
| 17 | In-file members of the cycle are left alone. |
| 18 | - `LowestEdge` -- B. The cross-file member lowest in op order is voided; every |
| 19 | other member proceeds. |
| 20 | - `WholeCycle` -- C. The member highest in op order wins wholly; every other |
| 21 | member of the cycle is voided. |
| 22 | |
| 23 | A member is exempt from voiding under every rule if another member of the same |
| 24 | cycle is in its causal past: an author who saw the other move and moved anyway |
| 25 | is informed, not racing. (The `Flag::Torn` correction of `file_identity.md` §4.4 |
| 26 | made the same distinction.) |
| 27 | |
| 28 | ## C1. Two-file cycle (the shipped case) |
| 29 | |
| 30 | `a="abc\n"`, `b="xyz\n"`; `M1=(5,1)` moves the whole of a into b after `b[0]`; |
| 31 | `M2=(5,2)` moves the whole of b into a after `a[0]`. |
| 32 | |
| 33 | | Rule | a | b | |
| 34 | |---|---|---| |
| 35 | | D | `""` | `"axyz\nbc\n"` | |
| 36 | | ConfineVictim | `"axyz\nbc\n"` | `""` | |
| 37 | | ConfineCycle | `"abc\n"` | `"xyz\n"` | |
| 38 | | LowestEdge | `"axyz\nbc\n"` | `""` | |
| 39 | | WholeCycle | `"axyz\nbc\n"` | `""` | |
| 40 | |
| 41 | **The prediction that matters**: `ConfineVictim` does *not* stop a file |
| 42 | emptying. It confines M1, whereupon M2's anchor content is home in a, so M2 |
| 43 | completes into a and carries b's whole block with it. The collapse is mirrored, |
| 44 | not prevented. If that holds, a rule phrased as a change to *what demotion does* |
| 45 | cannot deliver what candidate A was posed to deliver, and confinement has to be |
| 46 | a property of the cycle. Three of the five rules agree on this case; only |
| 47 | `ConfineCycle` gives each file its own block back. |
| 48 | |
| 49 | ## C2. Three-file cycle |
| 50 | |
| 51 | `a="abc\n"`, `b="xyz\n"`, `c="123\n"`; `M1=(7,1)` a into b after `b[0]`, |
| 52 | `M2=(7,2)` b into c after `c[0]`, `M3=(7,3)` c into a after `a[0]`. |
| 53 | |
| 54 | | Rule | a | b | c | |
| 55 | |---|---|---|---| |
| 56 | | D | `""` | `"a1xyz\n23\nbc\n"` | `""` | |
| 57 | | ConfineVictim | `"a1xyz\n23\nbc\n"` | `""` | `""` | |
| 58 | | ConfineCycle | `"abc\n"` | `"xyz\n"` | `"123\n"` | |
| 59 | | LowestEdge | `"a1xyz\n23\nbc\n"` | `""` | `""` | |
| 60 | | WholeCycle | `"a123\nbc\n"` | `"xyz\n"` | `""` | |
| 61 | |
| 62 | B and C come apart here, as the brief says they must. B breaks one edge, the |
| 63 | chain that remains is acyclic, and the two survivors cascade into one file: B is |
| 64 | barely better than D at length three. C empties one file, and that file was |
| 65 | emptied by the winning author's own move. |
| 66 | |
| 67 | ## C3. Four-file cycle |
| 68 | |
| 69 | `a="abc\n"`, `b="xyz\n"`, `c="123\n"`, `d="pqr\n"`; `M1=(9,1)` a into b after |
| 70 | `b[0]`, `M2=(9,2)` b into c after `c[0]`, `M3=(9,3)` c into d after `d[0]`, |
| 71 | `M4=(9,4)` d into a after `a[0]`. |
| 72 | |
| 73 | | Rule | a | b | c | d | |
| 74 | |---|---|---|---|---| |
| 75 | | D | `""` | `"ap1xyz\n23\nqr\nbc\n"` | `""` | `""` | |
| 76 | | ConfineVictim | `"ap1xyz\n23\nqr\nbc\n"` | `""` | `""` | `""` | |
| 77 | | ConfineCycle | `"abc\n"` | `"xyz\n"` | `"123\n"` | `"pqr\n"` | |
| 78 | | LowestEdge | `"ap1xyz\n23\nqr\nbc\n"` | `""` | `""` | `""` | |
| 79 | | WholeCycle | `"apqr\nbc\n"` | `"xyz\n"` | `"123\n"` | `""` | |
| 80 | |
| 81 | Three files emptied under D, B and A-as-phrased; one under C; none under |
| 82 | ConfineCycle. |
| 83 | |
| 84 | ## C4. Mixed cycle: one in-file member, two cross-file |
| 85 | |
| 86 | `a="abc\n"`, `b="wxyz"`. `M1=(5,1)` moves a into b after `b[0]='w'`, crossing. |
| 87 | `M2=(5,2)` moves `"wx"` within b to after `'y'`, in-file. `M3=(5,3)` moves |
| 88 | `"yz"` out of b into a after `a[0]`, crossing. |
| 89 | |
| 90 | | Rule | a | b | |
| 91 | |---|---|---| |
| 92 | | D | `""` | everything, 8 bytes | |
| 93 | | ConfineVictim | `"aywxzbc\n"` | `""` | |
| 94 | | ConfineCycle | `"abc\n"` | `"ywxz"` | |
| 95 | | LowestEdge | `"aywxzbc\n"` | `""` | |
| 96 | | WholeCycle | `"ayzbc\n"` | `"wx"` | |
| 97 | |
| 98 | This is where C is dearest: it voids M2, an in-file move that never touched the |
| 99 | boundary, because it happened to be in the cycle. ConfineCycle lets M2 complete |
| 100 | and is the only rule that does. |
| 101 | |
| 102 | ## C5. Cycle with an edit inside a cycling block |
| 103 | |
| 104 | C1 plus `E=(5,3)`, a third replica inserting `"!"` between `b` and `c` of a's |
| 105 | block, concurrently with both moves. |
| 106 | |
| 107 | | Rule | a | b | |
| 108 | |---|---|---| |
| 109 | | D | `""` | `"axyz\nb!c\n"` | |
| 110 | | ConfineVictim | `"axyz\nb!c\n"` | `""` | |
| 111 | | ConfineCycle | `"ab!c\n"` | `"xyz\n"` | |
| 112 | | LowestEdge | `"axyz\nb!c\n"` | `""` | |
| 113 | | WholeCycle | `"axyz\nb!c\n"` | `""` | |
| 114 | |
| 115 | The edit survives under every rule and stays with its block under every rule. |
| 116 | Only the file the block is in differs, so the edit costs nothing to any |
| 117 | candidate. |
| 118 | |
| 119 | ## C6. Supersession cycle |
| 120 | |
| 121 | C1's M1 and M2, and then `M3=(6,1)`: replica 1, having received M2, moves its |
| 122 | own block again, anchoring after the last byte of b's original content. M3 |
| 123 | supersedes M1 (it claims the same content and is later), so M1 owns nothing and |
| 124 | leaves the graph; the cycle is `{M2, M3}` and M2 is in M3's causal past. |
| 125 | |
| 126 | | Rule | a | b | |
| 127 | |---|---|---| |
| 128 | | D | `"xyz\nabc\n"` | `""` | |
| 129 | | ConfineVictim | `""` | `"xyz\nabc\n"` | |
| 130 | | ConfineCycle | `""` | `"xyz\nabc\n"` | |
| 131 | | LowestEdge | `""` | `"xyz\nabc\n"` | |
| 132 | | WholeCycle | `""` | `"xyz\nabc\n"` | |
| 133 | |
| 134 | Every candidate agrees, and every candidate honours the informed re-move; the |
| 135 | causal guard is what makes ConfineCycle agree rather than voiding M3 along with |
| 136 | M2. The status quo is the outlier: it demotes M2, M3 then follows M2's block, |
| 137 | and a block whose author twice said "into b" renders in a. |
| 138 | |
| 139 | ## C7. In-file cycles must not move |
| 140 | |
| 141 | `reg_nested_destinations` (`ALPHA`, two moves with mutually nested |
| 142 | destinations) renders `5678901ABCDE234FGHIJ` under every rule, with the same |
| 143 | demotion flags, and the self-anchoring move (a cycle of length one) is likewise |
| 144 | untouched: no candidate may reach an in-file cycle at all. |
| 145 | |
| 146 | ## Sweep |
| 147 | |
| 148 | Over the same generator as `mstage`, three files, three replicas: |
| 149 | |
| 150 | - `ConfineCycle` will void the most moves and empty the fewest files. |
| 151 | - `LowestEdge` and `ConfineVictim` will be indistinguishable on two-file |
| 152 | cycles, which will be the great majority, and will separate only where a |
| 153 | cycle is longer than two. |
| 154 | - Moves rendering in a file their author did not name will be highest under D, |
| 155 | about the same under B and A-as-phrased, lowest under ConfineCycle, with C |
| 156 | between. |
| 157 | - No rule will lose a byte or render one twice, and every rule will be |
| 158 | order-independent, because none of them reads anything but the operation set. |