Magnet Network — SIS-PoW laboratory

Status: closed on 2026-10-10 with a negative result. No acceptable SIS work function was found for the tested constructions; see the closing note and ADR 0020. The code and evidence below stay as a research record; no further experiments are planned.

Private research into lattice-based Proof of Work for a future Magnet Network. This repository currently verifies Short Integer Solutions and studies candidate PoW constructions. It now includes an experimental linear-chain prototype; there is no currency, production network or GPU miner.

English is the primary repository language. Russian is secondary: see the Russian documentation index.

Implemented

• Exact Python verifier and an independently implemented Rust verifier.
• Bounded binary test adapters and independent Python/Rust SHAKE256 matrix expansion.
• Exhaustive solver for tiny instances with a hard search budget.
• Manual, boundary, exhaustive and cross-language differential tests.
• Reproducible studies of solution availability, reuse and sparse screening.
• Bounded search policies with initial-acquisition and component accounting.
• Exact bounded meet-in-the-middle search and local time/allocation comparisons.
• Incremental norm-ball search and common cooperative time/allocation budgets.
• Native Rust ball/MITM search, bounded local protocol and larger toy CPU studies.
• Exact LLL kernel reduction, independently audited certificates and finite probes.
• Canonical research headers, trusted-context proofs and nonce/reuse studies.
• Optional pinned native FLINT LLL with exact certificate audits and practical comparisons.
• Paid nonce/time/payload selection policies with a separate research score predicate.
• Complete bounded exact sphere search on certified kernel lattices.
• Joint header families, four-target sweeps and explicit descriptive work models.
• On-demand practical lattice policies with streaming hits and bounded exact-instance preparation caches.
• Windows Job time/commit ceilings, immutable checkpoints and censored-attempt accounting.
• Fresh nonce/parent schedules and externally trusted laboratory header admission.
• Independent native SHA-256, strict score targets and full laboratory admission.
• Persistent paid vector campaigns with shared budgets and shuffled seeded repeats.
• Persistent multi-vector FIFO pools, paid combinations and joint header grinding.
• Paid MITM/sparse/LLL/limited BKZ/sieve portfolio with externally bounded campaigns.
• MGB1 body/recipient/target commitments and fixed-policy laboratory chain admission.
• Explicit construction/parameter/work decisions scoped to demonstration use.
• Independent complete Rust MGB1 parser and fixed-policy linear chain engine.
• Bounded real-block forks, atomic canonical replay and delivery/partition simulation.
• Synthetic retarget hypotheses and concrete paid block-reuse counterexamples.
• Exact precommitted-pool correlation laws, complete matrix audits and paid fresh-header supply studies.
• Paid bounded adaptive retention, replayed JSON checkpoints and independent native hit admission.
• Optional exact CUDA SIS verification, tested against Python/Rust on a local CMP 50HX.
• Bounded on-device unit-sparse candidate acquisition with paid chunk ledgers and independent CPU/native audits.
• Exact sparse-column CPU/CUDA acquisition with boolean-only readback and larger bounded chunks.
• Independent native Rust column search and fused CUDA kernels with paid chunks, owned sessions and matched-domain audits.
• Matched in-process scalar CPU/GPU search through unit triples with per-weight prefix and failure accounting.
• Bounded non-unit sparse search, independent complete-ledger audits and paid fresh-matrix refresh with direction accounting.
• Cooperative component budgets across sparse/ball/MITM acquisition, paid direction retention and frozen budget-response campaigns.
• Independent native small-coefficient search, strict framed reconciliation, late-witness audits and fresh-seed comparisons.
• Matched in-process small-coefficient CPU/CUDA chunks, complete negative-mask audits and durable interruption evidence.
• Explicit nominal A/B work definitions and frozen paid nonce-screening attacks with strong controls, independent ledger/native audits and insufficient-evidence reporting.
• Precommitted fresh-stream D3 replication: 576 audited campaigns, sufficient controls and no declared screening trigger; next D4 amortisation.
• Conditional exact full-kernel transfer laws, exhaustive finite-field checks and eight audited D4 integration workers; general reuse resistance remains open.
• Research-only B-H header-score repair: a public gate avoids rejected challenges' SIS preparation; 16 audited batches reject fresh-SIS-per-hash amplification for this candidate.

The ordinary check gate uses standard libraries. Cargo builds offline without third-party crates. Explicit practical-LLL surveys additionally use an isolated hash-pinned python-flint research environment; see the report below. GitHub Actions are intentionally absent; checks and experiments run locally.

Run locally

Tested on Windows with Python 3.12.10 and Rust 1.98.1, including rustfmt and clippy. Other platforms must repeat the checks before claiming support.

python scripts/check.py
python scripts/screening_survey.py
python scripts/screening_replication.py
python scripts/preparation_survey.py
python scripts/header_gate_survey.py
python scripts/native_coefficient_survey.py
python scripts/toy_survey.py
python scripts/reuse_survey.py
python scripts/strategy_survey.py
python scripts/mitm_survey.py
python scripts/budget_survey.py
python scripts/native_survey.py
python scripts/lattice_survey.py
python scripts/binding_survey.py
python scripts/grinding_survey.py
python scripts/joint_survey.py
python scripts/chain_survey.py
python scripts/fork_survey.py
python scripts/work_weight_study.py
python scripts/supply_survey.py
python scripts/difficulty_survey.py
python scripts/resource_survey.py

The complete lattice sphere survey uses the explicit optional environment:

python scripts/sphere_survey.py --python artifacts/flint-env/Scripts/python.exe
artifacts/flint-env/Scripts/python.exe scripts/integrated_survey.py
python scripts/windows_survey.py --python artifacts/flint-env/Scripts/python.exe
python scripts/campaign_survey.py --python artifacts/flint-env/Scripts/python.exe
python scripts/portfolio_survey.py --python artifacts/flint-env/Scripts/python.exe
python scripts/soak_survey.py --python artifacts/flint-env/Scripts/python.exe
python scripts/adaptive_survey.py --python artifacts/flint-env/Scripts/python.exe
artifacts/flint-env/Scripts/python.exe scripts/portfolio_checks.py
python scripts/rejection_cost.py
python scripts/mine_lab_chain.py
python scripts/endurance_fuzz.py --seconds 3600

The first command runs formatting/lint checks, tests and a deterministic Python/Rust differential corpus. Surveys study bounded toy instances; they do not benchmark production mining. Reports are written to ignored artifacts/.

Documentation

• Closing note: negative result and closure decision.
• Critical path and frozen D2/D3 protocol.
• Findings so far and open work-weight questions.
• Matched small-coefficient CPU/CUDA: bounded D5 pilot.
• Matched small-coefficient contract.
• Independent native small-coefficient search: five-task block.
• Native small-coefficient exchange contract.
• Native small-coefficient baseline decision.
• Cooperative acquisition and retention: five-task block.
• Cooperative component-budget contract.
• Cooperative budgets and retention decision.
• Small coefficients and paid matrix refresh.
• Small-coefficient contract.
• Small coefficients and refresh decision.
• Matched CPU/GPU search and unit-triple evidence.
• Matched search contract.
• Matched scope and unit-triple decision.
• Native Rust and fused CUDA measured baselines.
• Native/fused contract and timing scopes.
• Baseline decision and open production-work gate.
• Column arithmetic optimization and CPU/GPU comparison.
• Optimized column-search contract.
• Paid GPU unit-sparse acquisition.
• CPU/CUDA candidate-search contract.
• Executed CUDA verification and next GPU stage.
• Exact GPU verification contract.
• Research and consensus plan.
• Implemented SIS-LAB-v1 specification.
• Current status and verification.
• Backlog 1–10 milestone.
• Backlog 11–15 milestone.
• Paid adaptive retention results.
• Adaptive policy contract.
• Adaptive retention decision.
• Local GPU readiness and first experiments.
• Exact precommitted-pool supply study.
• Supply model and resource contract.
• Fixed-pool correlations and open adaptive-work gate.
• Native full-chain specification.
• Fork and retarget experiments.
• Fork simulation and open work-weight decision.
• Experimental construction and chain decision.
• Paid pool/solver specification.
• Experimental block and linear-chain specification.
• Solution reuse study.
• Search strategies and component accounting.
• Meet-in-the-middle search and local measurements.
• Norm-ball search and common local budgets.
• Native CPU search and larger toy instances.
• Native search laboratory protocol.
• Exact lattice-reduction specification.
• LLL availability and missed-solution study.
• Lattice-probe decision.
• Research header and local generator protocol.
• Independent generation and header-binding study.
• Header binding and work-pricing decision.
• Practical LLL and paid header-selection study.
• Optional backend and grinding interfaces.
• Optimized-solving and header-selection decision.
• Exact sphere, joint headers and work-model study.
• Sphere and work-model interfaces.
• Eligible scores versus SIS work pricing.
• Paid practical search and preprocessing study.
• Integrated lattice policy interfaces.
• Preprocessing accounting decision.
• External windows and fresh-context study.
• External resource and lab admission interfaces.
• Trusted header surface and difficulty requirements.
• Independent native score/admission interfaces.
• Persistent campaign and repeated-window interfaces.
• Native admission and seeded campaign study.
• Independent acceptance and campaign accounting decision.
• Research boundary decision.
• Threat model.
• Language policy.
• Original SIS proposal: historical hypotheses, not an accepted security specification.

Scope boundary

The original SIS1 laboratory format accepts a caller-supplied matrix. The new MGH1 bound proof format derives A internally from a research header and requires trusted external context. Accepting an arbitrary matrix or miner-chosen policy would allow deliberately easy instances. These remain local research tools.

Production difficulty/chainwork, wallets and payments are not implemented. MGB1 linear engines and the fixed-policy fork tree are experimental prototypes. Dynamic-target experiments use a separate synthetic model. Small-instance results do not establish GPU advantage, ASIC resistance, post-quantum security or mainnet parameters. MagnetGate is unchanged.

Closed: the negative-result note states the conclusion, its limits and the conditions for reopening. External cryptographic review of that note is the one outstanding request. A valid SIS solution is not proof of network service delivery or of a particular amount of computation.

License

MIT. See LICENSE.