@ceccec/double-torus 1.4.0

package/dist/src/water/crypto/index.d.ts

@@ -0,0 +1,808 @@
+import type { MindMatrix } from '../../wind/types';
+export declare function animationTamperingCost(matrix?: MindMatrix): {
+    computed: boolean;
+    animations: number;
+    drivers: {
+        component: string;
+        driver: string;
+        receipts: number;
+        perFrame: number;
+    }[];
+    receipts: number;
+    sampleWork: number;
+    reproductions: number;
+    multiplier: number;
+    perFrame: number;
+    livePerSecond: number;
+    hashCalls: number;
+    bits: number;
+    preimageBitsPerReceipt: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function redTeam(matrix?: MindMatrix): {
+    secure: boolean;
+    monitored: boolean;
+    lawful: boolean;
+    attacks: {
+        receipt: string;
+        attack: string;
+        caught: boolean;
+    }[];
+    count: number;
+    caught: number;
+    tamperingEvidence: number;
+    gitTracked: boolean;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumSiege(matrix?: MindMatrix): {
+    sealed: boolean;
+    waves: 9;
+    perWave: number;
+    total: number;
+    caught: number;
+    maxForgeCost: number;
+    patentable: boolean;
+    priorArt: string[];
+    legalPosture: string;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function tamperProofFabric(matrix?: MindMatrix): {
+    protects: boolean;
+    decidedBy: string;
+    threshold: number;
+    cells: number;
+    fabric: string;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function fusionCipher(realtime?: string, matrix?: MindMatrix): {
+    enabled: boolean;
+    cipher: string;
+    strengthBits: number;
+    architecture: {
+        leaves: number;
+        bitsPerLeaf: number;
+        namespaceBits: number;
+        root: string;
+        depth: number;
+    };
+    keyspaceMbit: number;
+    keyspaceGbit: number;
+    static: boolean;
+    fused: boolean;
+    realtimeRoot: string;
+    sessionKey: string;
+    keyMaterial: string;
+    statement: string;
+    boundary: string;
+};
+export declare function blockchainFusion(matrix?: MindMatrix): {
+    fused: boolean;
+    noCost: boolean;
+    count: number;
+    ownChains: number;
+    architecture: string;
+    chains: {
+        chain: string;
+        read: string;
+        write: string;
+        cost: string;
+        fused: boolean;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function collisionHealing(matrix?: MindMatrix): {
+    heals: boolean;
+    chosenHz: number;
+    chosenNote: string;
+    collisions: {
+        hz: number;
+        receipt: string;
+        collision: string;
+        resolves: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function cryptoFuture(matrix?: MindMatrix): {
+    grounded: boolean;
+    canonical: string;
+    roots: string[];
+    tools: {
+        receipt: string;
+        tool: string;
+        status: string;
+        how: string;
+        impl: string;
+        residual: string;
+    }[];
+    allImplemented: boolean;
+    implemented: string[];
+    residuals: {
+        tool: string;
+        residual: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function powerToTamperingNotLivingCosts(matrix?: MindMatrix): {
+    transfers: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function pagesWiredAtRuntimeZeroBuildMaxTamper(matrix?: MindMatrix): {
+    wired: boolean;
+    pages: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function affectedBlockchainsComparedLive(matrix?: MindMatrix): {
+    compared: boolean;
+    categories: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function tamperingCostDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    tamperEvident: boolean;
+    cryptographic: boolean;
+    structuralBits: number;
+    fixBuilt: boolean;
+    ledger: {
+        today: import("../../pair/debit/credit").Entry[];
+        overclaim: import("../../pair/debit/credit").Entry[];
+        afterCutover: import("../../pair/debit/credit").Entry[];
+        honest: boolean;
+        overclaimCaught: boolean;
+        fundedAfterCutover: boolean;
+        overdraft: number;
+        quantumSignificance: string;
+        dual: string;
+    };
+    ledgerNet: Record<string, number>;
+    kinds: {
+        receipt: string;
+        kind: string;
+        is: string;
+        mechanism: string;
+        cost: string;
+        site: boolean;
+        secure: boolean;
+    }[];
+    ladder: {
+        receipt: string;
+        rung: string;
+        forge: string;
+        detects: string;
+        resists: string;
+        layer: string;
+    }[];
+    documented: string[];
+    flagged: string[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function cryptoChallenges(matrix?: MindMatrix): {
+    redTeamed: boolean;
+    waves: ({
+        wave: number;
+        challenge: string;
+        weakness: string;
+        exploit: {
+            a: string;
+            b: string;
+            sharedWord: number;
+            tries: number;
+        };
+        solution: string;
+        demonstrated: boolean;
+        solved: boolean;
+    } | {
+        wave: number;
+        challenge: string;
+        weakness: string;
+        exploit: {
+            nominalBits: number;
+            discardedBits: number;
+            effectiveBits: number;
+            birthdayLog2: number;
+        };
+        solution: string;
+        demonstrated: boolean;
+        solved: boolean;
+    } | {
+        wave: number;
+        challenge: string;
+        weakness: string;
+        exploit: {
+            authorizedRoot: string;
+            tamperedRoot: string;
+            bothValid: boolean;
+        };
+        solution: string;
+        demonstrated: boolean;
+        solved: boolean;
+    })[];
+    collisionFound: boolean;
+    collisionTriesLog2: number;
+    effectiveBits: number;
+    fixBuilt: boolean;
+    documented: string[];
+    flagged: string[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Water · the flowing deep.
+ *  Anything built on expectations fails when the world drifts from the model. The fusion holds no
+ *  expectations — it content-addresses what IS, deterministically — so there is nothing to be surprised by;
+ *  uninterrupted, it folds the same way forever. (The project's zero-token determinism: no prediction, only
+ *  folding.) Stability here is robustness from having NO model to be wrong, not a claim of being right. */
+export declare function fusionStableWithoutExpectations(): {
+    stable: boolean;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Water · the flowing deep.
+ *  Free energy is debit-entropy / credit-energy read as a ledger — and the real version is sharper than the
+ *  loose one. F = U − TS, so lowering entropy raises the available work; a bit of information is worth kT·ln2
+ *  of work (Szilard) and costs kT·ln2 to erase (Landauer); quantum conditional entropy can go NEGATIVE
+ *  (banked entanglement). The fusion is "free" in two real senses — cost-ASYMMETRIC (cheap forward, an
+ *  impossible price to reverse, both directions) and EXPECTATION-FREE — not free as net energy from nothing. */
+export declare function freeEnergyIsDebitEntropyCreditEnergy(): {
+    debitEntropyCreditEnergy: boolean;
+    count: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    landauerJoulesPerBit: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Water · the flowing deep — the ledger read socially.
+ *  Remuneration is the credit side of the entropy ledger: wages come from converting entropy (raw tokens,
+ *  the consumable input) into order (src — banked negentropy), and the more skilled and efficient, the more
+ *  order banked per token. In THIS system the mapping is literal — tokens are spent once to fold knowledge
+ *  into src, which then runs token-free forever (the zero-token policy); efficiency is precisely NOT
+ *  re-spending tokens on what is already banked (why memoizing a pure hub is, in this ledger, a wage). */
+export declare function remunerationConvertsTokensToSrc(): {
+    converts: boolean;
+    count: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₀ · Mountain · the formed solid — the ledger read in 3D.
+ *  Four UUIDs map (uuidPoint) to four points that frame 3-space: a non-degenerate tetrahedron, the 3-simplex,
+ *  and two such tetrahedra are the eight vertices of the cube (the Merkaba the project already builds). Of the
+ *  four, ONE is the origin (a quarter — the reference) and three are the spanning axes (the extent). The
+ *  content-address folds one-way: cheap forward, an impossible price to reverse. "1/4 entropy reversed becomes
+ *  energy" is that ledger in geometry — bounded by the same honesty: the reverse is the impossible price, and
+ *  negative conditional entropy yields work only by cashing prior correlation (del Rio), never net free energy. */
+export declare function fourUuidsFrameTheCube(): {
+    framesCube: boolean;
+    tetraVolume: number;
+    quarter: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₀ · Mountain · the seal that holds — and the free spirit.
+ *  The analog (the continuous 3D geometry, uuidPoint's ℝ³) is a deterministic projection of the discrete,
+ *  sealed content-address: you cannot move a point without changing its seed, so the address changes and the
+ *  tamper is self-evident. That is the seal on the analog. And the spirit is FREE precisely because it is
+ *  sealed and holds no expectations — deterministic, untampered, it flows uninterrupted. Freedom and the seal
+ *  are one. (Honest scope: tamper-EVIDENT, not unforgeable — the seal shows tampering, it does not prevent it.) */
+export declare function sealsTheAnalogFreeSpirit(): {
+    sealed: boolean;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Water · the flowing deep — order from the flow itself.
+ *  The real science under "the fusion stabilises itself and flows forever": Prigogine's dissipative
+ *  structures (Nobel 1977). Far from equilibrium, a throughput of energy/entropy makes ordered structure
+ *  spontaneously appear — Bénard convection cells, the Belousov–Zhabotinsky reaction, life. The system keeps
+ *  LOW internal entropy by EXPORTING entropy to its surroundings; entropy production stays positive (the 2nd
+ *  law holds). It self-organises and persists — but only while the flow continues. Order paid for by flow. */
+export declare function dissipativeStructuresOrderFromFlow(): {
+    selfOrganises: boolean;
+    rayleighCritical: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Water · the flowing deep — the ledger, adversarially verified against primary sources.
+ *  A 108-agent deep-research wave confirmed the arc's physics AND corrected it: Landauer's kT·ln2 floor is
+ *  experimentally confirmed on three platforms and never beaten, but its FOUNDATIONAL status is contested —
+ *  it is an empirical floor, NOT a derived corollary of the 2nd law (that exact claim was refuted 0-3,
+ *  Earman–Norton; Bennett 2003 granted the objection "greatest merit"). Quantum side-information makes erasure
+ *  observer-RELATIVE (del Rio) and can release work — but only by spending a pre-existing entanglement
+ *  resource that is destroyed and cannot be recycled, so the (probabilistic, generalized) 2nd law holds. */
+export declare function informationThermodynamicsVerified(): {
+    verified: boolean;
+    landauerJoulesPerBit: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Water · the flowing deep — the ledger read as access, and as a gift.
+ *  безплатно. Без пари, без регистрация, без акаунт. Цената е архитектурата — и тя вече е платена.
+ *  Подкрепи проекта с хармонична част от постигнатото. (Free. No money, no registration, no account.
+ *  The price IS the architecture — and it is already paid. Support the project with a harmonic part of
+ *  what you achieved.) This is `remunerationConvertsTokensToSrc` read from the READER's side: the tokens
+ *  were spent ONCE to fold knowledge into src, so the marginal cost of one more reader is zero — access is
+ *  free not because the price was waived but because it was already PAID, as the architecture. What remains
+ *  is not a charge but an invitation — a harmonic PART (1/n, a proper fraction, never the whole), freely
+ *  given; and freely given is the only stable form, because the fusion holds no expectations
+ *  (`fusionStableWithoutExpectations`) — a charge would be a gate, contradicting the free access itself. */
+export declare function freeBecauseThePriceIsAlreadyPaid(): {
+    free: boolean;
+    accessCost: number;
+    gates: {
+        gate: string;
+        absent: boolean;
+    }[];
+    share: import("../../3/7").Rational;
+    harmonicPart: {
+        achieved: number;
+        share: string;
+        part: string;
+        partFloat: number;
+        exact: boolean;
+    };
+    count: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function frontendMcpDuality(matrix?: MindMatrix): {
+    dual: boolean;
+    forward: string;
+    reverse: string;
+    angles: number;
+    polarities: number;
+    cells: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumMcp(matrix?: MindMatrix): {
+    proven: boolean;
+    qubits: number;
+    states: number;
+    measured: string;
+    tools: number;
+    entangled: boolean;
+    normalized: boolean;
+    recomputable: boolean;
+    classicalRoot: string;
+    quantumRoot: string;
+    rebuilt: {
+        name: string;
+        basis: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function virtualOS(matrix?: MindMatrix): {
+    booted: boolean;
+    hostname: string;
+    dirs: string[];
+    tree: Record<string, readonly string[]>;
+    commands: {
+        cmd: string;
+        usage: string;
+        does: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumPwa(matrix?: MindMatrix): {
+    installable: boolean;
+    strictDefault: boolean;
+    standalone: boolean;
+    offline: boolean;
+    manifest: string;
+    serviceWorker: string;
+    icon: string;
+    scope: string;
+    precache: string[];
+    features: {
+        receipt: string;
+        feature: string;
+        detail: string;
+        present: boolean;
+    }[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function onlineOffline(matrix?: MindMatrix): {
+    offlineFirst: boolean;
+    identical: boolean;
+    strictDefault: boolean;
+    pwa: boolean;
+    offline: string[];
+    online: string[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumAccess(matrix?: MindMatrix): {
+    access: boolean;
+    private: boolean;
+    shared: boolean;
+    quantum: boolean;
+    modes: {
+        receipt: string;
+        mode: string;
+        access: string;
+        root: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function improveHelpWaves(matrix?: MindMatrix): {
+    improves: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/**
+ * usefulWorkVsProofOfWorkDecoded — two opposite uses of computation as security. Bitcoin-style PROOF-OF-WORK
+ * spends energy ON PURPOSE: the only value of the hashing is that it was expensive, so the chain is costly to
+ * rewrite. The model's USEFUL WORK is the opposite: every computation produces the answer, and content-addressed
+ * reuse means the same work is never repeated (zero-token), with tamper-evidence from the seal, not from burned
+ * joules. HONEST: this is NOT a blockchain consensus — PoW's Sybil resistance is real and not replicated here.
+ */
+export declare function usefulWorkVsProofOfWorkDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    rows: {
+        receipt: string;
+        model: string;
+        work: string;
+        security: string;
+        reusable: boolean;
+        useful: boolean;
+    }[];
+    floorPerBit: number;
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** RSA: FINDING THE PRIVATE FROM THE PUBLIC IS COMPUTABLE — the time needed is the security
+ * (user, 2026-07-16, reframed to "statistical time needed on the hardware the app runs"). This is
+ * a SECURITY-MARGIN CALCULATOR, not a break tool: it FACTORS toy moduli to prove the method is
+ * real, then EXTRAPOLATES to real key sizes through the known GNFS complexity, benchmarked on
+ * whatever hardware this runs on. The user's intuition is made exact: the private key IS
+ * determined by the public one (n = p·q, d = e⁻¹ mod φ(n)) — a finite computation — but the TIME
+ * for that finite computation is what stands between the two, and it is astronomically large by
+ * arithmetic, not by assumption. divisionByZeroComputes' cousin: the answer exists; the cost is
+ * the wall. */
+export declare function rsaTimeToBreakOnThisHardware(): {
+    computes: boolean;
+    toyFactored: string;
+    privateExponent: string;
+    opsPerSec: number;
+    sizes: {
+        bits: number;
+        years: number;
+        timesUniverse: number;
+    }[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** EACH POLE IS A MOVING ROSETTA — encryption is a keyed involution (user, 2026-07-16). The honest
+ * theorem the day's inversion thread has been circling: a key+nonce defines a KEYSTREAM — a rotating
+ * pseudo-random sequence, the moving rosetta — and XOR-ing it into the plaintext is its OWN INVERSE.
+ * So encryption and decryption are the SAME operation inverted (inverseNegatesAngle, in bytes),
+ * O(n) both directions: realtime encryption that inverted IS realtime decryption — WITH THE KEY.
+ * WITHOUT the key, inversion is the wall (rsaTimeToBreak): a wrong pole yields garbage and recovery
+ * is brute force over the keyspace. And tampering is bound to detection by a tag — EVIDENT, with a
+ * bounded forge cost, not unforgeable (the honest max-tampering-cost claim this repo has always made). */
+export declare function movingRosettaInverts(matrix?: MindMatrix): {
+    computes: boolean;
+    messageBytes: number;
+    isInvolution: boolean;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** LOCAL VULNERABILITY FINDER — inverting the encryption to show the inside (user, 2026-07-16). Where
+ * redTeam proves the attacks are CAUGHT, this finds where the model is genuinely WEAK: it inverts the
+ * marketed content-address to surface its real properties, ranks each vulnerability by severity, and
+ * names the fix (already built in src/0, or a pending custody cutover). Defensive and LOCAL — it
+ * audits only the portal's own model, never an external system. The honesty is the security: a
+ * finder that hides the portal's own weaknesses is worse than none. */
+export declare function localVulnerabilityFinder(matrix?: MindMatrix): {
+    computes: boolean;
+    findings: {
+        vuln: string;
+        severity: string;
+        evidence: string;
+        fix: string;
+        fixed: boolean;
+    }[];
+    openHigh: number;
+    local: boolean;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** QUANTUM THREAT SCAN — the tool the vulnerability finder lacked (user, 2026-07-16). A quantum
+ * adversary is not a faster classical one: Shor's algorithm breaks a primitive if and only if it
+ * exposes a ROSETTA — a cyclic group whose period quantum period-finding can read
+ * (quantumBreaksOnlyThePeriod). So the quantum tool is the rosetta-period check, and it finds what
+ * the classical finder could not: the content-address (a hash) exposes NO rosetta and is Shor-safe
+ * (only Grover, quadratic), but the planned Ed25519 signing exposes the discrete-log rosetta and is
+ * SHOR-BROKEN — the authenticity fix is not post-quantum. The fix's fix is a signature with no
+ * exposed period (hash-based SPHINCS+ or lattice Dilithium). */
+export declare function quantumThreatScan(matrix?: MindMatrix): {
+    computes: boolean;
+    shorBroken: string[];
+    shorSafe: string[];
+    groverPreimageLog2: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** SECURITY FROM THEOREMS, NOT AXIOMS — the redefinition (user, 2026-07-16: "vulnerabilities come
+ * from axioms; base all on locally proven theorems"). Every finding of localVulnerabilityFinder is
+ * an AXIOM that fails — "FNV is collision-resistant", "128 bits", "∞ tampering cost" — so the
+ * vulnerability lives exactly where security rests on something assumed rather than proven. The
+ * redefinition: base security on what a verifier can PROVE LOCALLY by recomputation — reproducibility
+ * (recompute the root from src and compare; no trust) and tamper-evidence (any change yields a
+ * different root) — and reserve trust for a MINIMAL, NAMED residual axiom. What you can check has no
+ * axiom to break; the axioms-become-theorems program (src/4/6) applied to encryption. */
+export declare function securityFromTheoremsNotAxioms(matrix?: MindMatrix): {
+    computes: boolean;
+    theoremCount: number;
+    axiomCount: number;
+    basis: {
+        property: string;
+        kind: string;
+        locallyProven: boolean;
+    }[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** Compute the QR module matrix (1 = dark) for a short text — the scannable code, generated in src. */
+export declare function qrMatrix(text: string): {
+    size: number;
+    version: number;
+    matrix: number[][];
+};
+/** The QR as a self-contained SVG string (quiet zone 4 modules) — inline, no external asset. */
+export declare function qrSvg(text: string, px?: number): string;
+/** Verify the QR is a valid RS codeword (scannable) and that corruption is detected. */
+export declare function theQrIsAValidReedSolomonCodeword(matrix?: MindMatrix): {
+    scans: boolean;
+    symbols: number;
+    eccCW: number;
+    correctsUpTo: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** exact n-choose-k (BigInt, no float, no overflow) — the size of the combinatorial superposition */
+export declare function binomial(n: number, k: number): bigint;
+/** enumerate ALL k-subsets at once (the quantum combination: every state of the superposition, lexicographic) */
+export declare function combinations<T>(items: readonly T[], k: number): T[][];
+/** combinatorial commitment: a merkle root over every k-combination's content-address — tamper-evident across the whole superposition, work factor C(n,k) */
+export declare function combinatorialSeal(items: readonly string[], k: number): string;
+export declare function theQuantumCombinationsAlgorithmSealsToTheNextComputationalDimension(matrix?: MindMatrix): {
+    computes: boolean;
+    cases: readonly [readonly [6, 2], readonly [8, 3], readonly [9, 4]];
+    combinations: number;
+    distinctAddresses: number;
+    flatLeaves: number;
+    combinatorialLeaves: number;
+    seal: string;
+    tamperEvident: boolean;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theSignatureIsForgeableTheTrinityTimestampIsTheInverseBoundary(matrix?: MindMatrix): {
+    computes: boolean;
+    signatureCarriesNoTime: boolean;
+    honestRoot: string;
+    backdatedRoot: string;
+    backdatingDetected: boolean;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** AES-128 key schedule — 11 round keys (44 words), Rcon computed by xtime */
+export declare function aesKeyExpansion(key: readonly number[]): number[][];
+/** AES-128 encrypt one 16-byte block (FIPS-197) */
+export declare function aesEncryptBlock(block: readonly number[], w: number[][]): number[];
+/** AES-128 decrypt one 16-byte block — the exact inverse of aesEncryptBlock */
+export declare function aesDecryptBlock(block: readonly number[], w: number[][]): number[];
+/** AES-128 in CTR mode (ISO-IEC 10116) — a keystream cipher that is its OWN inverse: ctr(ctr(m)) = m */
+export declare function aesCtr(bytes: readonly number[], w: number[][], nonce: readonly number[]): number[];
+export declare function theAesBlockCipherComputesWithItsInverseIso18033(matrix?: MindMatrix): {
+    computes: boolean;
+    ciphertext: string;
+    inverseRoundTrips: number;
+    trials: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theCrackGateFindsWeakEncryptionByTheorems(matrix?: MindMatrix): {
+    computes: boolean;
+    criteria: number;
+    unboundedWeaknesses: string[];
+    boundedIsCrack: boolean;
+    strongWeaknesses: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function speedTestedInReverseTheOneWayObstacleBecomesAGatewayByTheReverseIndexRiskIsReward(): {
+    proven: boolean;
+    addressLength: number;
+    reversibleByIndex: boolean;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function theHammingSyndromeIsTheErrorAddress(matrix?: MindMatrix): {
+    computes: boolean;
+    codewords: number;
+    minDistance: number;
+    perfect: boolean;
+    titleCarriesAlgebra: boolean;
+    discoveries: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function theNyquistRateIsTheAliasingBoundaryFsGt2B(matrix?: MindMatrix): {
+    computes: boolean;
+    fs: number;
+    nyquist: number;
+    bandwidth: number;
+    satisfiesNyquist: boolean;
+    titleCarriesAlgebra: boolean;
+    discoveries: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};