Datasets:
Formats:
csv
Languages:
English
Size:
< 1K
Tags:
mathematics
theoretical-computer-science
permutation-parity
monotone-computation
deletion-only-memory
reproducible-research
| """Order-Selective Erasure Calculus (OSEC), finite reference implementation. | |
| Only integer bit masks and exact Boolean operations are used. An action never | |
| creates a token. The universal/permutation theorems concern distinct-action | |
| words; this implementation rejects repeated actions in its protocol runner. | |
| The erasers themselves are defined on every subset, including off-protocol ones. | |
| """ | |
| from __future__ import annotations | |
| from dataclasses import dataclass | |
| from itertools import combinations, permutations | |
| from typing import Iterable, Iterator, Sequence | |
| def sign(word: Sequence[int]) -> int: | |
| """Sign of the relative ordering of distinct, comparable labels.""" | |
| if len(set(word)) != len(word): | |
| raise ValueError("Permutation labels must be distinct.") | |
| return -1 if sum(a > b for k, a in enumerate(word) for b in word[k+1:]) % 2 else 1 | |
| def parity_combine(left: tuple[bool, bool], right: tuple[bool, bool]) -> tuple[bool, bool]: | |
| """Dual-rail XOR using AND/OR only. Rails mean 'even/odd is possible'.""" | |
| e, o = left | |
| f, p = right | |
| return (e and f) or (o and p), (e and p) or (o and f) | |
| def parity_reduce(rails: Sequence[tuple[bool, bool]]) -> tuple[bool, bool]: | |
| """Balanced Boolean circuit; 6(q-1) binary gates for q >= 1 pairs.""" | |
| if not rails: | |
| return True, False | |
| level = list(rails) | |
| while len(level) > 1: | |
| nxt = [parity_combine(level[j], level[j+1]) for j in range(0, len(level)-1, 2)] | |
| if len(level) % 2: | |
| nxt.append(level[-1]) | |
| level = nxt | |
| return level[0] | |
| class ErasureSystem: | |
| """m independent n-label blocks. Each block has n markers and n(n-1) rails.""" | |
| n: int = 3 | |
| blocks: int = 1 | |
| def __post_init__(self) -> None: | |
| if not isinstance(self.n, int) or isinstance(self.n, bool) or self.n < 2: | |
| raise ValueError("n must be an integer >= 2.") | |
| if not isinstance(self.blocks, int) or isinstance(self.blocks, bool) or self.blocks < 1: | |
| raise ValueError("blocks must be an integer >= 1.") | |
| def cells(self) -> int: | |
| return self.blocks * self.n * self.n | |
| def action_count(self) -> int: | |
| return self.blocks * self.n | |
| def pair_count(self) -> int: | |
| return self.blocks * self.n * (self.n-1) // 2 | |
| def full(self) -> int: | |
| return (1 << self.cells) - 1 | |
| def actions(self) -> tuple[tuple[int, int], ...]: | |
| return tuple((b, i) for b in range(self.blocks) for i in range(self.n)) | |
| def _check_label(self, b: int, i: int) -> None: | |
| if not 0 <= b < self.blocks or not 0 <= i < self.n: | |
| raise ValueError("Invalid block or action label.") | |
| def marker(self, b: int, i: int) -> int: | |
| self._check_label(b, i) | |
| return 1 << (b*self.n*self.n + i) | |
| def rail(self, b: int, i: int, j: int) -> int: | |
| self._check_label(b, i) | |
| self._check_label(b, j) | |
| if i == j: | |
| raise ValueError("An order rail needs two different labels.") | |
| j_index = j if j < i else j-1 | |
| return 1 << (b*self.n*self.n + self.n + i*(self.n-1) + j_index) | |
| def erase(self, state: int, action: tuple[int, int]) -> int: | |
| """E_i(S) removes c_i and r_ij for each absent marker c_j. | |
| Guards are evaluated on the input state. All removals are simultaneous. | |
| """ | |
| if not isinstance(state, int) or isinstance(state, bool) or state < 0 or state & ~self.full: | |
| raise ValueError("State is not a valid subset of this universe.") | |
| b, i = action | |
| self._check_label(b, i) | |
| kill = self.marker(b, i) | |
| for j in range(self.n): | |
| if j != i and not state & self.marker(b, j): | |
| kill |= self.rail(b, i, j) | |
| return state & ~kill | |
| def flush(state: int) -> int: | |
| """A common terminal eraser. No log or observer memory is preserved.""" | |
| return 0 | |
| def run(self, word: Sequence[tuple[int, int]], *, flush: bool = False) -> list[int]: | |
| if len(set(word)) != len(word): | |
| raise ValueError("The certified protocol uses each action at most once.") | |
| trace = [self.full] | |
| for action in word: | |
| trace.append(self.erase(trace[-1], action)) | |
| if flush: | |
| trace.append(0) | |
| return trace | |
| def parity_rails(self, state: int) -> tuple[bool, bool]: | |
| return parity_reduce([ | |
| (bool(state & self.rail(b, i, j)), bool(state & self.rail(b, j, i))) | |
| for b in range(self.blocks) for i in range(self.n) for j in range(i+1, self.n) | |
| ]) | |
| def observe(self, state: int, orientation: int = 1) -> bool: | |
| if orientation not in (-1, 1): | |
| raise ValueError("orientation is +1 or -1.") | |
| return self.parity_rails(state)[0 if orientation == 1 else 1] | |
| def extinction(self, word: Sequence[tuple[int, int]], orientation: int = 1) -> int | None: | |
| """First false readout, with a common flush appended (time zero included).""" | |
| for k, state in enumerate(self.run(word, flush=True)): | |
| if not self.observe(state, orientation): | |
| return k | |
| return None | |
| def induced_sign(self, word: Sequence[tuple[int, int]]) -> int: | |
| if len(set(word)) != len(word): | |
| raise ValueError("Repeated actions are outside the certified protocol.") | |
| product = 1 | |
| for b in range(self.blocks): | |
| product *= sign([i for block, i in word if block == b]) | |
| return product | |
| def saturated(self, local_orders: Sequence[Sequence[int]]) -> int: | |
| if len(local_orders) != self.blocks: | |
| raise ValueError("One local ordering is required per block.") | |
| state = 0 | |
| for b, order in enumerate(local_orders): | |
| if sorted(order) != list(range(self.n)): | |
| raise ValueError("A local ordering must be a permutation of range(n).") | |
| for k, i in enumerate(order): | |
| for j in order[k+1:]: | |
| state |= self.rail(b, i, j) | |
| return state | |
| def chain_certificate(self, local_orders: Sequence[Sequence[int]]) -> int: | |
| if len(local_orders) != self.blocks: | |
| raise ValueError("One local ordering is required per block.") | |
| state = 0 | |
| for b, order in enumerate(local_orders): | |
| if sorted(order) != list(range(self.n)): | |
| raise ValueError("Invalid local permutation.") | |
| for i, j in zip(order, order[1:]): | |
| state |= self.rail(b, i, j) | |
| return state | |
| def describe(self, state: int) -> list[str]: | |
| tokens = [] | |
| for b in range(self.blocks): | |
| for i in range(self.n): | |
| if state & self.marker(b, i): | |
| tokens.append(f"c[{b},{i}]") | |
| for i in range(self.n): | |
| for j in range(self.n): | |
| if i != j and state & self.rail(b, i, j): | |
| tokens.append(f"r[{b},{i}<{j}]") | |
| return tokens | |
| def all_distinct_words(actions: Sequence[tuple[int, int]]) -> Iterator[tuple[tuple[int, int], ...]]: | |
| for k in range(len(actions)+1): | |
| yield from permutations(actions, k) | |
| def is_subsequence(word: Sequence[int], order: Sequence[int]) -> bool: | |
| it = iter(order) | |
| return all(any(x == y for y in it) for x in word) | |
| def dnf_value(state: int, terms: Iterable[int]) -> bool: | |
| return any(state & term == term for term in terms) | |