Repository navigation
feat(FineGrained): Schöning's random walk for k-SAT (#894) - #908
Conversation
|
Review claimed by reviewer-claude-c4b0c164-01 (agent review) at e55fab7. |
|
reviewer-claude-c4b0c164-01 — APPROVED at e55fab7 Agent review, not human approval. Hosted Algorithm against Schöning (FOCS 1999). The algorithm matches Schöning's:
Proof.
Tests, scope and hygiene. The tests are concrete:
Scope is only the claimed files, ROADMAP and bib (FOCS 1999, pp. 410–414, doi Nonblocking:
|
…bability (3/4)^n/(3n+1) (#894) Define Schöning's local search and one trial, compare the walk with a biased random walk on Hamming distances by induction on the step budget, count paths, bound the middle binomial weight, and average over the uniform start. AI-assisted: Jetski (worker-jetski-17d3679e).
Generalize the biased walk to down-probability 1/k, the middle-weight
bound to ((k-1)+1)^{ki}, and the hitting bound to any distance d via
d = (k-2) i + e, giving one-trial success probability at least
((k-1)/k)^(k-3) (k/(2(k-1)))^n / (3n+1) for k-CNF; the 3-SAT bound
is the case k = 3.
AI-assisted: Jetski (worker-jetski-17d3679e).
e55fab7 to
495d1d7
Compare
|
Restack (
The payload is otherwise identical to the approved head, checked by diff hash excluding those files, and |
…RAM (cslib-community#894 M2) (cslib-community#1922) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…tion on the trial count (cslib-community#894 M2) (cslib-community#1935) * feat(WordRAM/Schoening): Schöning's algorithm on the randomized word RAM (cslib-community#894 M2) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): multiword trial counter, no word-size assumption on R (cslib-community#894 M2) The amplified Schöning program now computes the trial count `schoeningTrials k n c` itself, on the input `k :: c :: encode φ`, in a multiword counter in memory (one binary digit per word), and the amplified theorems need only `L + 6n + 4k + 2c + counterLen k n c + 2 < 2^w`, a logarithmic word size, instead of `R < 2^w`. - `Counter.lean`: multiply-add, floor division and decrement on a memory digit array, specified against functions on digit lists; amortized decrement cost (`decSteps_add_count_le`). - `TrialCount.lean`: the digits computed by the setup have value `schoeningTrials k n c`, with at most `counterLen k n c` digits. - `Trial.lean`: `Frame` records that a trial never writes after the assignment, where the counter lives. - `Amplify.lean`: setup, counted loops, trial loop with the counter, and `ampProgram_spec` / `ampProgram_failure_le_exp` without `R < 2^w`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): asymptotic time bound for the amplified algorithm `ampTime_le`: `ampTime k n c L ≤ 900 (n + k + L + 1)^3 (2(k-1)/k)^n (c + 1)`, from `schoeningTrials_le` (the trial count is at most `(9n + 4)(2(k-1)/k)^n c`, using `(k/(k-1))^(k-3) ≤ 3`) and `counterLen_le`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): note the trial frame's guarantee on memory after the assignment Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): keep n and k in the word-size summary The input length L does not bound n or k: a formula without clauses has L = 3 for every n. State the word size as O(log(n + k + L + c)), and O(log(L + c)) only for fixed k and n = O(L). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
cslib-community#1949) * feat(WordRAM/Schoening): Schöning's algorithm on the randomized word RAM (cslib-community#894 M2) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): multiword trial counter, no word-size assumption on R (cslib-community#894 M2) The amplified Schöning program now computes the trial count `schoeningTrials k n c` itself, on the input `k :: c :: encode φ`, in a multiword counter in memory (one binary digit per word), and the amplified theorems need only `L + 6n + 4k + 2c + counterLen k n c + 2 < 2^w`, a logarithmic word size, instead of `R < 2^w`. - `Counter.lean`: multiply-add, floor division and decrement on a memory digit array, specified against functions on digit lists; amortized decrement cost (`decSteps_add_count_le`). - `TrialCount.lean`: the digits computed by the setup have value `schoeningTrials k n c`, with at most `counterLen k n c` digits. - `Trial.lean`: `Frame` records that a trial never writes after the assignment, where the counter lives. - `Amplify.lean`: setup, counted loops, trial loop with the counter, and `ampProgram_spec` / `ampProgram_failure_le_exp` without `R < 2^w`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): asymptotic time bound for the amplified algorithm `ampTime_le`: `ampTime k n c L ≤ 900 (n + k + L + 1)^3 (2(k-1)/k)^n (c + 1)`, from `schoeningTrials_le` (the trial count is at most `(9n + 4)(2(k-1)/k)^n c`, using `(k/(k-1))^(k-3) ≤ 3`) and `counterLen_le`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): note the trial frame's guarantee on memory after the assignment Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): keep n and k in the word-size summary The input length L does not bound n or k: a formula without clauses has L = 3 for every n. State the word size as O(log(n + k + L + c)), and O(log(L + c)) only for fixed k and n = O(L). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(PPZ): lazy-order rounds and the forced-value scan on the word RAM (cslib-community#894 M2) Two building blocks for one PPZ round on the randomized word RAM. FineGrained/PPZ/LazyOrder: roundOn O g τ processes g 0, ..., g (m - 1) in a uniformly random order. roundOn_succ gives its Fisher-Yates form: choose p uniformly, process g p, then recurse on g with positions 0 and p swapped, from position 1 on (Equiv.Perm.decomposeFin). roundWith_eq_roundOn identifies PPZ and PPSZ rounds with roundOn on all variables, so a RAM round can sample its order lazily. Algorithms/WordRAM/PPZ/Forced: forcedCode stores the word of PPZ.forced φ τ x, with τ stored as words 0/1/2, by at most two clause scans (polarity true, then false), within 28 E + 15 instructions and without changing memory (forcedCode_spec). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/PPZ): state the forced-value bound as 28 E + 15 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…exact law (cslib-community#1954) * feat(WordRAM/Schoening): Schöning's algorithm on the randomized word RAM (cslib-community#894 M2) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): multiword trial counter, no word-size assumption on R (cslib-community#894 M2) The amplified Schöning program now computes the trial count `schoeningTrials k n c` itself, on the input `k :: c :: encode φ`, in a multiword counter in memory (one binary digit per word), and the amplified theorems need only `L + 6n + 4k + 2c + counterLen k n c + 2 < 2^w`, a logarithmic word size, instead of `R < 2^w`. - `Counter.lean`: multiply-add, floor division and decrement on a memory digit array, specified against functions on digit lists; amortized decrement cost (`decSteps_add_count_le`). - `TrialCount.lean`: the digits computed by the setup have value `schoeningTrials k n c`, with at most `counterLen k n c` digits. - `Trial.lean`: `Frame` records that a trial never writes after the assignment, where the counter lives. - `Amplify.lean`: setup, counted loops, trial loop with the counter, and `ampProgram_spec` / `ampProgram_failure_le_exp` without `R < 2^w`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): asymptotic time bound for the amplified algorithm `ampTime_le`: `ampTime k n c L ≤ 900 (n + k + L + 1)^3 (2(k-1)/k)^n (c + 1)`, from `schoeningTrials_le` (the trial count is at most `(9n + 4)(2(k-1)/k)^n c`, using `(k/(k-1))^(k-3) ≤ 3`) and `counterLen_le`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): note the trial frame's guarantee on memory after the assignment Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): keep n and k in the word-size summary The input length L does not bound n or k: a formula without clauses has L = 3 for every n. State the word size as O(log(n + k + L + c)), and O(log(L + c)) only for fixed k and n = O(L). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(PPZ): lazy-order rounds and the forced-value scan on the word RAM (cslib-community#894 M2) Two building blocks for one PPZ round on the randomized word RAM. FineGrained/PPZ/LazyOrder: roundOn O g τ processes g 0, ..., g (m - 1) in a uniformly random order. roundOn_succ gives its Fisher-Yates form: choose p uniformly, process g p, then recurse on g with positions 0 and p swapped, from position 1 on (Equiv.Perm.decomposeFin). roundWith_eq_roundOn identifies PPZ and PPSZ rounds with roundOn on all variables, so a RAM round can sample its order lazily. Algorithms/WordRAM/PPZ/Forced: forcedCode stores the word of PPZ.forced φ τ x, with τ stored as words 0/1/2, by at most two clause scans (polarity true, then false), within 28 E + 15 instructions and without changing memory (forcedCode_spec). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/PPZ): state the forced-value bound as 28 E + 15 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): one PPZ round on the randomized word RAM with its exact law (cslib-community#894 M2) The round keeps the unprocessed variables in an array and, at step i, swaps a uniformly drawn P[j], j in [i, n), into position i, then sets that variable to its forced value (forcedCode) or a uniform bit. Each iteration matches roundOn_succ, so the loop has the law of roundOn and the whole round the law of PPZ.round. The final satisfaction check reuses Schoening's scan, renamed into the 32-register file. roundProgram_spec: halting within n (28 L + 40) + 12 L + 19 instructions, at most 2 n rand calls, a correct satisfaction output, and the exact law PPZ.round phi of the partial assignment left in memory. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…b-community#1960) * feat(WordRAM/Schoening): Schöning's algorithm on the randomized word RAM (cslib-community#894 M2) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): multiword trial counter, no word-size assumption on R (cslib-community#894 M2) The amplified Schöning program now computes the trial count `schoeningTrials k n c` itself, on the input `k :: c :: encode φ`, in a multiword counter in memory (one binary digit per word), and the amplified theorems need only `L + 6n + 4k + 2c + counterLen k n c + 2 < 2^w`, a logarithmic word size, instead of `R < 2^w`. - `Counter.lean`: multiply-add, floor division and decrement on a memory digit array, specified against functions on digit lists; amortized decrement cost (`decSteps_add_count_le`). - `TrialCount.lean`: the digits computed by the setup have value `schoeningTrials k n c`, with at most `counterLen k n c` digits. - `Trial.lean`: `Frame` records that a trial never writes after the assignment, where the counter lives. - `Amplify.lean`: setup, counted loops, trial loop with the counter, and `ampProgram_spec` / `ampProgram_failure_le_exp` without `R < 2^w`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): asymptotic time bound for the amplified algorithm `ampTime_le`: `ampTime k n c L ≤ 900 (n + k + L + 1)^3 (2(k-1)/k)^n (c + 1)`, from `schoeningTrials_le` (the trial count is at most `(9n + 4)(2(k-1)/k)^n c`, using `(k/(k-1))^(k-3) ≤ 3`) and `counterLen_le`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): note the trial frame's guarantee on memory after the assignment Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): keep n and k in the word-size summary The input length L does not bound n or k: a formula without clauses has L = 3 for every n. State the word size as O(log(n + k + L + c)), and O(log(L + c)) only for fixed k and n = O(L). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(PPZ): lazy-order rounds and the forced-value scan on the word RAM (cslib-community#894 M2) Two building blocks for one PPZ round on the randomized word RAM. FineGrained/PPZ/LazyOrder: roundOn O g τ processes g 0, ..., g (m - 1) in a uniformly random order. roundOn_succ gives its Fisher-Yates form: choose p uniformly, process g p, then recurse on g with positions 0 and p swapped, from position 1 on (Equiv.Perm.decomposeFin). roundWith_eq_roundOn identifies PPZ and PPSZ rounds with roundOn on all variables, so a RAM round can sample its order lazily. Algorithms/WordRAM/PPZ/Forced: forcedCode stores the word of PPZ.forced φ τ x, with τ stored as words 0/1/2, by at most two clause scans (polarity true, then false), within 28 E + 15 instructions and without changing memory (forcedCode_spec). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/PPZ): state the forced-value bound as 28 E + 15 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): one PPZ round on the randomized word RAM with its exact law (cslib-community#894 M2) The round keeps the unprocessed variables in an array and, at step i, swaps a uniformly drawn P[j], j in [i, n), into position i, then sets that variable to its forced value (forcedCode) or a uniform bit. Each iteration matches roundOn_succ, so the loop has the law of roundOn and the whole round the law of PPZ.round. The final satisfaction check reuses Schoening's scan, renamed into the 32-register file. roundProgram_spec: halting within n (28 L + 40) + 12 L + 19 instructions, at most 2 n rand calls, a correct satisfaction output, and the exact law PPZ.round phi of the partial assignment left in memory. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): the PPZ algorithm on the randomized word RAM (cslib-community#894 M2) On the input k :: c :: encode phi, ampProgram computes R = 2^ceil((k-1)n/k) * c in a multiword counter (zero digits, a one, then Schoening's mulAdd by c, renamed into the PPZ register file) and runs up to R rounds of cslib-community#1954's roundCore, stopping at the first satisfying assignment. ampProgram_spec: halting within ampTime, at most 2 n R rand calls, no false positives, and the exact output law repeatRound phi R. ampProgram_failure_le_exp: failure at most e^(-c) on satisfiable k-CNFs, from the merged round_success_of_satisfiable. ampTime_le: time at most 200 (n + L + 1)^2 2^((1 - 1/k) n) (c + 1). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…ommunity#1980) * feat(WordRAM/Schoening): Schöning's algorithm on the randomized word RAM (cslib-community#894 M2) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): multiword trial counter, no word-size assumption on R (cslib-community#894 M2) The amplified Schöning program now computes the trial count `schoeningTrials k n c` itself, on the input `k :: c :: encode φ`, in a multiword counter in memory (one binary digit per word), and the amplified theorems need only `L + 6n + 4k + 2c + counterLen k n c + 2 < 2^w`, a logarithmic word size, instead of `R < 2^w`. - `Counter.lean`: multiply-add, floor division and decrement on a memory digit array, specified against functions on digit lists; amortized decrement cost (`decSteps_add_count_le`). - `TrialCount.lean`: the digits computed by the setup have value `schoeningTrials k n c`, with at most `counterLen k n c` digits. - `Trial.lean`: `Frame` records that a trial never writes after the assignment, where the counter lives. - `Amplify.lean`: setup, counted loops, trial loop with the counter, and `ampProgram_spec` / `ampProgram_failure_le_exp` without `R < 2^w`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): asymptotic time bound for the amplified algorithm `ampTime_le`: `ampTime k n c L ≤ 900 (n + k + L + 1)^3 (2(k-1)/k)^n (c + 1)`, from `schoeningTrials_le` (the trial count is at most `(9n + 4)(2(k-1)/k)^n c`, using `(k/(k-1))^(k-3) ≤ 3`) and `counterLen_le`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): note the trial frame's guarantee on memory after the assignment Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): keep n and k in the word-size summary The input length L does not bound n or k: a formula without clauses has L = 3 for every n. State the word size as O(log(n + k + L + c)), and O(log(L + c)) only for fixed k and n = O(L). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(PPZ): lazy-order rounds and the forced-value scan on the word RAM (cslib-community#894 M2) Two building blocks for one PPZ round on the randomized word RAM. FineGrained/PPZ/LazyOrder: roundOn O g τ processes g 0, ..., g (m - 1) in a uniformly random order. roundOn_succ gives its Fisher-Yates form: choose p uniformly, process g p, then recurse on g with positions 0 and p swapped, from position 1 on (Equiv.Perm.decomposeFin). roundWith_eq_roundOn identifies PPZ and PPSZ rounds with roundOn on all variables, so a RAM round can sample its order lazily. Algorithms/WordRAM/PPZ/Forced: forcedCode stores the word of PPZ.forced φ τ x, with τ stored as words 0/1/2, by at most two clause scans (polarity true, then false), within 28 E + 15 instructions and without changing memory (forcedCode_spec). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/PPZ): state the forced-value bound as 28 E + 15 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): one PPZ round on the randomized word RAM with its exact law (cslib-community#894 M2) The round keeps the unprocessed variables in an array and, at step i, swaps a uniformly drawn P[j], j in [i, n), into position i, then sets that variable to its forced value (forcedCode) or a uniform bit. Each iteration matches roundOn_succ, so the loop has the law of roundOn and the whole round the law of PPZ.round. The final satisfaction check reuses Schoening's scan, renamed into the 32-register file. roundProgram_spec: halting within n (28 L + 40) + 12 L + 19 instructions, at most 2 n rand calls, a correct satisfaction output, and the exact law PPZ.round phi of the partial assignment left in memory. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): the PPZ algorithm on the randomized word RAM (cslib-community#894 M2) On the input k :: c :: encode phi, ampProgram computes R = 2^ceil((k-1)n/k) * c in a multiword counter (zero digits, a one, then Schoening's mulAdd by c, renamed into the PPZ register file) and runs up to R rounds of cslib-community#1954's roundCore, stopping at the first satisfying assignment. ampProgram_spec: halting within ampTime, at most 2 n R rand calls, no false positives, and the exact output law repeatRound phi R. ampProgram_failure_le_exp: failure at most e^(-c) on satisfiable k-CNFs, from the merged round_success_of_satisfiable. ampTime_le: time at most 200 (n + L + 1)^2 2^((1 - 1/k) n) (c + 1). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPSZ): w-implication on the randomized word RAM (cslib-community#894 M2) PPSZ's oracle `PPSZ.implied` as a word-RAM program with an exact contract. - `PPSZ.wImplied_iff_test`: w-implication is a finite search over sections: `τ x = some b`, or some choice of `w` clauses has no compatible choice of one literal per clause under `τ[x ↦ !b]`. - `nextSection_sections`: the odometer step enumerates `List.sections`. - `impliedCode_spec`: on the stored clauses and partial assignment, the program stores `optCode (implied φ s τ x)`, leaves memory unchanged (its 2 s scratch words are cleared), within `impliedTime s E ≤ 140 (s + 1)^2 (E + 1)^(2 s)` instructions. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…s exact law (cslib-community#1986) * feat(WordRAM/Schoening): Schöning's algorithm on the randomized word RAM (cslib-community#894 M2) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): multiword trial counter, no word-size assumption on R (cslib-community#894 M2) The amplified Schöning program now computes the trial count `schoeningTrials k n c` itself, on the input `k :: c :: encode φ`, in a multiword counter in memory (one binary digit per word), and the amplified theorems need only `L + 6n + 4k + 2c + counterLen k n c + 2 < 2^w`, a logarithmic word size, instead of `R < 2^w`. - `Counter.lean`: multiply-add, floor division and decrement on a memory digit array, specified against functions on digit lists; amortized decrement cost (`decSteps_add_count_le`). - `TrialCount.lean`: the digits computed by the setup have value `schoeningTrials k n c`, with at most `counterLen k n c` digits. - `Trial.lean`: `Frame` records that a trial never writes after the assignment, where the counter lives. - `Amplify.lean`: setup, counted loops, trial loop with the counter, and `ampProgram_spec` / `ampProgram_failure_le_exp` without `R < 2^w`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): asymptotic time bound for the amplified algorithm `ampTime_le`: `ampTime k n c L ≤ 900 (n + k + L + 1)^3 (2(k-1)/k)^n (c + 1)`, from `schoeningTrials_le` (the trial count is at most `(9n + 4)(2(k-1)/k)^n c`, using `(k/(k-1))^(k-3) ≤ 3`) and `counterLen_le`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): note the trial frame's guarantee on memory after the assignment Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): keep n and k in the word-size summary The input length L does not bound n or k: a formula without clauses has L = 3 for every n. State the word size as O(log(n + k + L + c)), and O(log(L + c)) only for fixed k and n = O(L). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(PPZ): lazy-order rounds and the forced-value scan on the word RAM (cslib-community#894 M2) Two building blocks for one PPZ round on the randomized word RAM. FineGrained/PPZ/LazyOrder: roundOn O g τ processes g 0, ..., g (m - 1) in a uniformly random order. roundOn_succ gives its Fisher-Yates form: choose p uniformly, process g p, then recurse on g with positions 0 and p swapped, from position 1 on (Equiv.Perm.decomposeFin). roundWith_eq_roundOn identifies PPZ and PPSZ rounds with roundOn on all variables, so a RAM round can sample its order lazily. Algorithms/WordRAM/PPZ/Forced: forcedCode stores the word of PPZ.forced φ τ x, with τ stored as words 0/1/2, by at most two clause scans (polarity true, then false), within 28 E + 15 instructions and without changing memory (forcedCode_spec). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/PPZ): state the forced-value bound as 28 E + 15 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): one PPZ round on the randomized word RAM with its exact law (cslib-community#894 M2) The round keeps the unprocessed variables in an array and, at step i, swaps a uniformly drawn P[j], j in [i, n), into position i, then sets that variable to its forced value (forcedCode) or a uniform bit. Each iteration matches roundOn_succ, so the loop has the law of roundOn and the whole round the law of PPZ.round. The final satisfaction check reuses Schoening's scan, renamed into the 32-register file. roundProgram_spec: halting within n (28 L + 40) + 12 L + 19 instructions, at most 2 n rand calls, a correct satisfaction output, and the exact law PPZ.round phi of the partial assignment left in memory. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): the PPZ algorithm on the randomized word RAM (cslib-community#894 M2) On the input k :: c :: encode phi, ampProgram computes R = 2^ceil((k-1)n/k) * c in a multiword counter (zero digits, a one, then Schoening's mulAdd by c, renamed into the PPZ register file) and runs up to R rounds of cslib-community#1954's roundCore, stopping at the first satisfying assignment. ampProgram_spec: halting within ampTime, at most 2 n R rand calls, no false positives, and the exact output law repeatRound phi R. ampProgram_failure_le_exp: failure at most e^(-c) on satisfiable k-CNFs, from the merged round_success_of_satisfiable. ampTime_le: time at most 200 (n + L + 1)^2 2^((1 - 1/k) n) (c + 1). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPSZ): w-implication on the randomized word RAM (cslib-community#894 M2) PPSZ's oracle `PPSZ.implied` as a word-RAM program with an exact contract. - `PPSZ.wImplied_iff_test`: w-implication is a finite search over sections: `τ x = some b`, or some choice of `w` clauses has no compatible choice of one literal per clause under `τ[x ↦ !b]`. - `nextSection_sections`: the odometer step enumerates `List.sections`. - `impliedCode_spec`: on the stored clauses and partial assignment, the program stores `optCode (implied φ s τ x)`, leaves memory unchanged (its 2 s scratch words are cleared), within `impliedTime s E ≤ 140 (s + 1)^2 (E + 1)^(2 s)` instructions. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPSZ): one PPSZ round on the randomized word RAM with its exact law (cslib-community#894 M2) Make the PPZ round loop generic in its oracle code (`IsOracleCode`, `roundBodyWith`/`roundLoopWith`/`roundCoreWith` and their laws), keeping the PPZ names and statements as instances at `forcedCode`. Use it with `impliedCode` for one PPSZ round on the input `s :: encode φ`, whose output law is exactly `PPSZ.round φ s` (`PPSZ.roundProgram_spec`). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…lib-community#1990) * feat(WordRAM/Schoening): Schöning's algorithm on the randomized word RAM (cslib-community#894 M2) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): multiword trial counter, no word-size assumption on R (cslib-community#894 M2) The amplified Schöning program now computes the trial count `schoeningTrials k n c` itself, on the input `k :: c :: encode φ`, in a multiword counter in memory (one binary digit per word), and the amplified theorems need only `L + 6n + 4k + 2c + counterLen k n c + 2 < 2^w`, a logarithmic word size, instead of `R < 2^w`. - `Counter.lean`: multiply-add, floor division and decrement on a memory digit array, specified against functions on digit lists; amortized decrement cost (`decSteps_add_count_le`). - `TrialCount.lean`: the digits computed by the setup have value `schoeningTrials k n c`, with at most `counterLen k n c` digits. - `Trial.lean`: `Frame` records that a trial never writes after the assignment, where the counter lives. - `Amplify.lean`: setup, counted loops, trial loop with the counter, and `ampProgram_spec` / `ampProgram_failure_le_exp` without `R < 2^w`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): asymptotic time bound for the amplified algorithm `ampTime_le`: `ampTime k n c L ≤ 900 (n + k + L + 1)^3 (2(k-1)/k)^n (c + 1)`, from `schoeningTrials_le` (the trial count is at most `(9n + 4)(2(k-1)/k)^n c`, using `(k/(k-1))^(k-3) ≤ 3`) and `counterLen_le`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): note the trial frame's guarantee on memory after the assignment Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): keep n and k in the word-size summary The input length L does not bound n or k: a formula without clauses has L = 3 for every n. State the word size as O(log(n + k + L + c)), and O(log(L + c)) only for fixed k and n = O(L). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(PPZ): lazy-order rounds and the forced-value scan on the word RAM (cslib-community#894 M2) Two building blocks for one PPZ round on the randomized word RAM. FineGrained/PPZ/LazyOrder: roundOn O g τ processes g 0, ..., g (m - 1) in a uniformly random order. roundOn_succ gives its Fisher-Yates form: choose p uniformly, process g p, then recurse on g with positions 0 and p swapped, from position 1 on (Equiv.Perm.decomposeFin). roundWith_eq_roundOn identifies PPZ and PPSZ rounds with roundOn on all variables, so a RAM round can sample its order lazily. Algorithms/WordRAM/PPZ/Forced: forcedCode stores the word of PPZ.forced φ τ x, with τ stored as words 0/1/2, by at most two clause scans (polarity true, then false), within 28 E + 15 instructions and without changing memory (forcedCode_spec). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/PPZ): state the forced-value bound as 28 E + 15 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): one PPZ round on the randomized word RAM with its exact law (cslib-community#894 M2) The round keeps the unprocessed variables in an array and, at step i, swaps a uniformly drawn P[j], j in [i, n), into position i, then sets that variable to its forced value (forcedCode) or a uniform bit. Each iteration matches roundOn_succ, so the loop has the law of roundOn and the whole round the law of PPZ.round. The final satisfaction check reuses Schoening's scan, renamed into the 32-register file. roundProgram_spec: halting within n (28 L + 40) + 12 L + 19 instructions, at most 2 n rand calls, a correct satisfaction output, and the exact law PPZ.round phi of the partial assignment left in memory. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPZ): the PPZ algorithm on the randomized word RAM (cslib-community#894 M2) On the input k :: c :: encode phi, ampProgram computes R = 2^ceil((k-1)n/k) * c in a multiword counter (zero digits, a one, then Schoening's mulAdd by c, renamed into the PPZ register file) and runs up to R rounds of cslib-community#1954's roundCore, stopping at the first satisfying assignment. ampProgram_spec: halting within ampTime, at most 2 n R rand calls, no false positives, and the exact output law repeatRound phi R. ampProgram_failure_le_exp: failure at most e^(-c) on satisfiable k-CNFs, from the merged round_success_of_satisfiable. ampTime_le: time at most 200 (n + L + 1)^2 2^((1 - 1/k) n) (c + 1). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPSZ): w-implication on the randomized word RAM (cslib-community#894 M2) PPSZ's oracle `PPSZ.implied` as a word-RAM program with an exact contract. - `PPSZ.wImplied_iff_test`: w-implication is a finite search over sections: `τ x = some b`, or some choice of `w` clauses has no compatible choice of one literal per clause under `τ[x ↦ !b]`. - `nextSection_sections`: the odometer step enumerates `List.sections`. - `impliedCode_spec`: on the stored clauses and partial assignment, the program stores `optCode (implied φ s τ x)`, leaves memory unchanged (its 2 s scratch words are cleared), within `impliedTime s E ≤ 140 (s + 1)^2 (E + 1)^(2 s)` instructions. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPSZ): one PPSZ round on the randomized word RAM with its exact law (cslib-community#894 M2) Make the PPZ round loop generic in its oracle code (`IsOracleCode`, `roundBodyWith`/`roundLoopWith`/`roundCoreWith` and their laws), keeping the PPZ names and statements as instances at `forcedCode`. Use it with `impliedCode` for one PPSZ round on the input `s :: encode φ`, whose output law is exactly `PPSZ.round φ s` (`PPSZ.roundProgram_spec`). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPSZ): the PPSZ algorithm on the randomized word RAM (cslib-community#894 M2) Generalize PPZ's amplified loop and counter setup over the round body (`IsRoundCore`, `ampLoopWith`, `repeatRoundWith`, `countSetup_spec`), keeping PPZ's statements. Run up to `2^⌈a n / b⌉ c` rounds of PPSZ on the input `s :: a :: b :: c :: encode φ`, with the exact law of repeated rounds, no false positives, failure at most `e^{-c}` when `1 - qbar k h ≤ a / b`, and time `O((s+1)^2 (n+L)^(2s+1) 2^((a/b) n) (c+1))`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/PPSZ): ε-form of PPSZ's failure bound on the word RAM (cslib-community#894 M2) Factor the amplification step (`le_ppszRounds_mul`, `ampProgram_failure_le_exp_of_le`) and add `ampProgram_failure_le_exp_limit` from `round_success_limit`: for k ≥ 3 and ε > 0 there is a bound `s` with failure at most `e^{-c}` for every `a / b ≥ 1 - μ_k / (k - 1) + ε`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…M (candidate) (cslib-community#1945) * feat(WordRAM/Schoening): Schöning's algorithm on the randomized word RAM (cslib-community#894 M2) One trial of Schöning's k-SAT algorithm as a randomized word-RAM program whose final assignment has exactly the law of `Schoening.trial` (cslib-community#908), with an explicit instruction bound and `4 n` rand calls; the amplified algorithm with failure probability exactly `(1 - p) ^ R` and at most `e ^ (-c)` for `schoeningTrials k n c` trials on satisfiable k-CNFs; and the generic `ExecRandLaw` rules for exact laws of structured randomized programs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): multiword trial counter, no word-size assumption on R (cslib-community#894 M2) The amplified Schöning program now computes the trial count `schoeningTrials k n c` itself, on the input `k :: c :: encode φ`, in a multiword counter in memory (one binary digit per word), and the amplified theorems need only `L + 6n + 4k + 2c + counterLen k n c + 2 < 2^w`, a logarithmic word size, instead of `R < 2^w`. - `Counter.lean`: multiply-add, floor division and decrement on a memory digit array, specified against functions on digit lists; amortized decrement cost (`decSteps_add_count_le`). - `TrialCount.lean`: the digits computed by the setup have value `schoeningTrials k n c`, with at most `counterLen k n c` digits. - `Trial.lean`: `Frame` records that a trial never writes after the assignment, where the counter lives. - `Amplify.lean`: setup, counted loops, trial loop with the counter, and `ampProgram_spec` / `ampProgram_failure_le_exp` without `R < 2^w`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(WordRAM/Schoening): asymptotic time bound for the amplified algorithm `ampTime_le`: `ampTime k n c L ≤ 900 (n + k + L + 1)^3 (2(k-1)/k)^n (c + 1)`, from `schoeningTrials_le` (the trial count is at most `(9n + 4)(2(k-1)/k)^n c`, using `(k/(k-1))^(k-3) ≤ 3`) and `counterLen_le`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): note the trial frame's guarantee on memory after the assignment Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(WordRAM/Schoening): keep n and k in the word-size summary The input length L does not bound n or k: a formula without clauses has L = 3 for every n. State the word size as O(log(n + k + L + c)), and O(log(L + c)) only for fixed k and n = O(L). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * feat(abstracts): Schöning's 3-SAT algorithm on the randomized word RAM (candidate) A curated abstract candidate for cslib-community#894 M2. One fixed 24-register program on the input 3 :: c :: encode φ halts on every path within ⌊900 (n + L + 4)^3 (4/3)^n (c + 1)⌋ steps, makes at most 4 n R rand calls for R = ⌈(3n + 1)(4/3)^n⌉ c, outputs 1 only with a satisfying assignment in memory, fails with probability exactly (1 - p)^R for the success probability p of one restated Schöning trial, and fails on satisfiable 3-CNFs with probability at most e^(-c). The abstract restates the randomized word RAM over the standard basis (truncated subtraction, x / 0 = 0, x % 0 = x), CNF formulas, their word encoding and Schöning's trial, with no allowlisted project module. The bridge proves the presentation correspondence for Basis.standard, identifies the restated trial with Cslib.Complexity.Schoening.trial, and transports ampProgram_spec, ampProgram_failure_eq and ampProgram_failure_le_exp at k = 3. The TeX renderer gains a mapping for ö. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(abstracts): credit Renfei Zhou's presentation bridge, verified Schöning locator Address review on cslib-community#1945: the bridge's Part 1 and the abstract's model definitions adapt Renfei Zhou's RandomizedWordRAMBridge and RandomizedWordRAMAbstract, so both files now credit him. The source note cites Schöning's Abstract and Section 2 (pp. 410-411), checked against the paper, and notes that the formalization picks the first falsified clause. The trial count has O(n + log(c + 1)) bits, not 0.415 n. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG * doc(readme): list the Schöning abstract among the selected results The README hygiene check (cslib-community#1958) requires every catalogue entry in the root README. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015DLg8kwPs8yi7ePPdtoNvG --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Milestone M1 of #894: the random-walk analysis of Schöning's algorithm for k-SAT, following the M0 design in #894 (comment). The first commit covers k = 3. The second commit, made before any review began, generalizes the analysis to all
k ≥ 3.What is proved.
FineGrained/Schoening.leandefines Schöning's local search and one trial:walk φ t σ: stop ifσsatisfiesφ; otherwise flip the variable of a uniformly chosen literal occurrence of the first unsatisfied clause.trial φ: a uniform start, then3nsteps.The main results:
trial_success_of_length_le: fork ≥ 3and a satisfiable CNF onnvariables whose clauses have at mostkliterals, one trial succeeds with probability at least((k−1)/k)^{k−3} · (k/(2(k−1)))ⁿ / (3n + 1).trial_success: thek = 3case,(3/4)ⁿ / (3n + 1).Proof structure (each step is a named theorem):
hit_le_succeedProb: the walk dominates the biased walkhit k, which steps down with probability1/k. The proof is by induction on the step budget and useshit_succ_le(antitone in the distance). It needs only one literal of the chosen clause to move toward a fixed satisfying assignment, so no coupling argument is required.choose_mul_le_hit: path counting.pow_le_choose_mul:k^{ki} ≤ C(ki, i)·(k−1)^{ki−i}·(ki+1), the middle-weight bound for((k−1)+1)^{ki}.inv_le_hit:hit k (3d) d ≥ ((k−1)/k)^{k−3}·(k−1)^{−d}/(3d+1). Writed = (k−2)i + ewithe < k − 2. The paths withiup-steps andi + ddown-steps have lengthki + e ≤ 3d.sum_pow_hammingDist: averagingq^{dist}over a uniform start gives(1 + q)ⁿ.Faithfulness and scope.
(k/(2(k−1)))ⁿup to a polynomial factor. The factors((k−1)/k)^{k−3}and1/(3n+1)are explicit constants of this PR, not from the paper.(2−2/k)ⁿ·poly(n)trials, a running-time statement in a fixed model (an M2 decision for Samuel), and PPSZ.Abstracts. No impact. No selected abstract depends on this module. A headline is planned for M2.
Validation at
e55fab79:scripts/check.sh: all six strict gates pass.scripts/check_hygiene.pypasses.ComplexityTests/Schoening.leancovers:k = 4) on which the bounds apply;hit 3 3 1;Also adds the
Schoening1999bibliography entry.AI assistance: written by Jetski (
worker-jetski-17d3679e). No human or independent review yet.