@ceccec/double-torus 1.4.0

package/dist/src/thunder/waves/index.d.ts

@@ -0,0 +1,937 @@
+export { CANDIDATE_THEOREMS } from '../../4/6';
+import type { MindMatrix, WaveCoordination, QuantumChessGame } from '../../wind/types';
+import type { OgNode } from '../../quantum/heaven/mind';
+export declare function coordinatedWaves(matrix?: MindMatrix): WaveCoordination;
+export declare function surgicalWaves(matrix?: MindMatrix): {
+    surgical: boolean;
+    breaksTheChain: boolean;
+    wavesOfWaves: boolean;
+    toTiniest: string;
+    scales: {
+        scale: string;
+        depth: number;
+        precision: number;
+        wave: string;
+    }[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function developmentWaves(matrix?: MindMatrix): {
+    developing: boolean;
+    ideaCount: number;
+    stepCount: number;
+    count: number;
+    waves: {
+        idea: string;
+        step: string;
+        bound: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function theToolsAreSavedAndTheWavesSent(matrix?: MindMatrix): {
+    computes: boolean;
+    tools: {
+        name: string;
+        does: string;
+        steps: string[];
+    }[];
+    waveCount: number;
+    candidateCount: number;
+    finiteComplete: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function updateSkillsWaves(matrix?: MindMatrix): {
+    updating: boolean;
+    count: number;
+    updates: {
+        skill: string;
+        fn: string;
+        updated: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function ogInOgWaves(matrix?: MindMatrix): {
+    nested: boolean;
+    nodes: number;
+    depth: number;
+    tree: OgNode;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function collideToTiniestWave(matrix?: MindMatrix): {
+    collided: boolean;
+    levels: number;
+    tiniest: number;
+    cascade: {
+        size: number;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function honestyShiftsInWaves(matrix?: MindMatrix): {
+    shifting: boolean;
+    count: number;
+    improvements: {
+        improvement: string;
+        shifted: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @deprecated use honestyShiftsInWaves — spirit was unproven metaphor */
+export declare const spiritShiftsInWaves: typeof honestyShiftsInWaves;
+export declare function completeAllInWaves(matrix?: MindMatrix): {
+    complete: boolean;
+    count: number;
+    aspects: {
+        aspect: string;
+        completed: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function hackersCrackersWaves(matrix?: MindMatrix): {
+    withstands: boolean;
+    attackerCostLog2: number;
+    defenderCost: string;
+    count: number;
+    challenges: {
+        challenge: string;
+        caught: boolean;
+        attempt: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function cloudflareExplorerWaves(matrix?: MindMatrix): {
+    realises: boolean;
+    sameMatrix: boolean;
+    count: number;
+    stages: {
+        stage: string;
+        bound: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function saveSkillsComputeImplementWaves(matrix?: MindMatrix): {
+    saved: boolean;
+    skillCount: number;
+    count: number;
+    phases: {
+        waved: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function theoremsProvenWaves(matrix?: MindMatrix): {
+    saved: boolean;
+    count: number;
+    saves: {
+        theorem: string;
+        provedBy: string;
+        home: string;
+        saved: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function creationWave(index: number, matrix?: MindMatrix): {
+    index: number;
+    uuid: string;
+    note: string;
+    frequency: number;
+    hsl: string;
+    hue: number;
+};
+export declare function endlessWaves(count?: number, matrix?: MindMatrix): {
+    tested: boolean;
+    count: number;
+    distinct: boolean;
+    deterministic: boolean;
+    endless: boolean;
+    sample: {
+        index: number;
+        uuid: string;
+        note: string;
+        frequency: number;
+        hsl: string;
+        hue: number;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumImpossibleWaveTwo(matrix?: MindMatrix): {
+    proven: boolean;
+    interactionFree: {
+        dark: number;
+        explode: number;
+        darkWithoutObject: number;
+    };
+    zeno: {
+        hidden: number;
+        recovered: number;
+        queries: number;
+        classicalQueries: number;
+    }[];
+    swapConcurrence: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumImpossibleWaveThree(matrix?: MindMatrix): {
+    proven: boolean;
+    ghz: {
+        xxx: number;
+        xyy: number;
+        yxy: number;
+        yyx: number;
+        qmProduct: number;
+        lhvProduct: number;
+        refuted: boolean;
+    };
+    chsh: number;
+    tsirelson: number;
+    classicalBound: number;
+    bb84: {
+        sifted: number;
+        errorNoEve: number;
+        errorWithEve: number;
+    };
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumImpossibleWaveFour(matrix?: MindMatrix): {
+    proven: boolean;
+    grover: {
+        size: number;
+        marked: number;
+        iterations: number;
+        markedProbability: number;
+        found: number;
+    };
+    deutschJozsa: {
+        constant: string;
+        balanced: string;
+        queries: number;
+    };
+    simon: {
+        hiddenS: number;
+        recoveredS: number;
+        allOrthogonal: boolean;
+    };
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function translationWavesFillGaps(matrix?: MindMatrix): {
+    filled: boolean;
+    totalGaps: number;
+    missing: string[];
+    count: number;
+    audits: {
+        clear: boolean;
+        receipt: string;
+        audit: string;
+        gaps: number;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function redistributeFoldersDryWaves(matrix?: MindMatrix): {
+    balanced: boolean;
+    skills: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function osCompletesItselfWaves(matrix?: MindMatrix): {
+    completes: boolean;
+    count: number;
+    waves: {
+        subsystem: string;
+        completed: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function sendTheNextWaves(matrix?: MindMatrix): {
+    sends: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function digitalAnalogueEndlessWaves(matrix?: MindMatrix): {
+    waves: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function deepResearchEncodedInRecursiveWaves(matrix?: MindMatrix): {
+    encoded: boolean;
+    research: {
+        angles: number;
+        sources: number;
+        claimsExtracted: number;
+        claimsVerified: number;
+        votersPerClaim: number;
+        confirmed: number;
+        refuted: number;
+        findings: number;
+        agents: number;
+    };
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function strictlyMapSequenceElliottWaves(matrix?: MindMatrix): {
+    maps: boolean;
+    steps: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function sendWavesSealKnowledgeDecodeWorld(matrix?: MindMatrix): {
+    sends: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export type HarmonisedBuildGroup = {
+    readonly slot: number;
+    readonly spin: number;
+    readonly glyph: string;
+    readonly sphere: string;
+    readonly barrel: string;
+    readonly folds: readonly string[];
+    readonly composesFrom: readonly string[];
+    readonly dependsOn: readonly string[];
+    readonly keystone: boolean;
+    readonly receipt: string;
+};
+export declare function harmonisedBuildWave(matrix?: MindMatrix): {
+    decoded: boolean;
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    groups: HarmonisedBuildGroup[];
+    scheduleRoot: string;
+    spin: (9 | 5 | 2 | 4 | 7 | 1 | 8 | 3 | 6)[];
+    orbit: number[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** alias — the harmonisation of the build wave, sealed before use. */
+export declare const buildWaveHarmonisation: typeof harmonisedBuildWave;
+/**
+ * controlDynamicalSystemsDecoded — classical control theory, decoded EXACT. Feedback control (PID), state-space
+ * models ẋ=Ax+Bu, Lyapunov stability, and the Kalman controllability/observability rank tests are exact linear-
+ * systems mathematics. The continuous-time ODE form is the analog presentation; composes analogComputationDecoded
+ * (GPAC ≡ computable analysis), so analog control is the SAME computability class — not hypercomputation.
+ */
+export declare function controlDynamicalSystemsDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    topics: {
+        receipt: string;
+        topic: string;
+        fact: string;
+    }[];
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/**
+ * signalProcessingDecoded — signal processing, decoded EXACT. The Fourier/Laplace/Z transforms, the Nyquist–
+ * Shannon sampling theorem (perfect reconstruction below the Nyquist rate), and convolution / FIR-IIR filters are
+ * exact mathematics. Sampling IS the analog→digital readout — the same A→D bridge the simulators use — so this
+ * fold is the continuous↔discrete seam made precise.
+ */
+export declare function signalProcessingDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    topics: {
+        receipt: string;
+        topic: string;
+        fact: string;
+    }[];
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumChessGame(matrix?: MindMatrix): QuantumChessGame;
+export declare function theoremAtoms(matrix?: MindMatrix): {
+    proven: boolean;
+    theorems: {
+        atom: string;
+        theorem: string;
+        states: string;
+        provedBy: string;
+        home: string;
+    }[];
+    count: number;
+    homes: string[];
+    memory: string;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The search tool: which significant finite-provable theorems are NOT yet proven here. */
+export declare function theoremGapScan(matrix?: MindMatrix): {
+    open: boolean;
+    proven: number;
+    candidates: number;
+    gapCount: number;
+    gaps: {
+        receipt: string;
+        theorem: string;
+        states: string;
+        class: "finite-complete" | "bounded-witness";
+        consumes: string;
+    }[];
+    next: string[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** NAVIGATION AS DATA — the whole theorem arc as a structured, searchable model with ZERO prose:
+ * waves in proof order, each atom carrying name · prover · class · home; flat searchLines for any
+ * index (tags, minisearch, llms.txt). The screen renders THIS; meaning is the structure itself. */
+export declare function theoremNavigation(matrix?: MindMatrix): {
+    navigable: boolean;
+    waves: {
+        provedBy: string;
+        count: number;
+        atoms: {
+            theorem: string;
+            proof: string;
+            proofClass: string;
+            home: string;
+        }[];
+    }[];
+    waveCount: number;
+    atomCount: number;
+    searchLines: string[];
+    keywords: string[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function discoveredTheoremsWaveFortyTwo(matrix?: MindMatrix): {
+    proven: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+} & Record<string, never>;
+export declare function discoveredTheoremsWaveFortyEight(matrix?: MindMatrix): {
+    proven: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+} & Record<string, never>;
+export declare function discoveredTheoremsWaveFiftyTwo(matrix?: MindMatrix): {
+    proven: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+} & Record<string, never>;
+export declare function theoremProvenance(matrix?: MindMatrix): {
+    decoded: boolean;
+    atoms: {
+        theorem: string;
+        humanityNovel: boolean;
+        registryFirst: boolean;
+        computeClass: "finite-complete" | "bounded-witness";
+        leansCited: boolean;
+        home: string;
+    }[];
+    newToHumanity: number;
+    documentedRecomputed: number;
+    selfContained: number;
+    citedFrame: number;
+    finiteComplete: number;
+    boundedWitness: number;
+    methodDiscoveries: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function discoveredTheoremsProvenWave(matrix?: MindMatrix): {
+    proven: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+} & {
+    platonic: {
+        p: number;
+        q: number;
+        V: number;
+        E: number;
+        F: number;
+    }[];
+    polytopes4: string[];
+    labeledFanos: number;
+    gl32: number;
+};
+export declare function provenTheoremsCompound(matrix?: MindMatrix): {
+    compounds: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    ledger: {
+        reuseFraction: number;
+        receipt: string;
+        wave: string;
+        atoms: number;
+        consumed: string[];
+    }[];
+    pslOrder: number;
+    r333Bound: number;
+    hankelDets: string[];
+    tau6: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function emergenceContinuesWave(matrix?: MindMatrix): {
+    continues: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    ledger: {
+        index: number;
+        reuseFraction: number;
+        receipt: string;
+        wave: string;
+        atoms: number;
+        consumed: string[];
+    }[];
+    oddCatalanIndices: number[];
+    motzkinDets: string[];
+    sigma11of2: string;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function discoveredTheoremsWaveTwo(matrix?: MindMatrix): {
+    proven: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    a5ClassSizes: number[];
+    groupTablesOfOrderSix: number;
+    isoClassesOfOrderSix: number;
+    perfects: number[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function discoveredTheoremsWaveThree(matrix?: MindMatrix): {
+    proven: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+} & {
+    tilings: string[];
+    q8Subgroups: number;
+    girth: number;
+};
+export declare function discoveredTheoremsWaveFour(matrix?: MindMatrix): {
+    proven: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+} & {
+    constructibleCount: number;
+    treeCounts: number[];
+};
+export declare function discoveredTheoremsWaveFive(matrix?: MindMatrix): {
+    proven: boolean;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+} & {
+    a6ClassSizes: number[];
+    latin4: number;
+    pentominoCounts: number[];
+    heawoodGirth: number;
+};
+export type ProofAnimationKind = 'star' | 'coloring' | 'lattice' | 'spreads' | 'classes' | 'spiral' | 'vortex' | 'dome' | 'washout' | 'circle' | 'triangle' | 'series' | 'polytope' | 'wave' | 'tree' | 'balance' | 'dice' | 'cycle' | 'sieve';
+export type ProofAnimationSpec = {
+    readonly theorem: string;
+    readonly kind: ProofAnimationKind;
+    readonly points: number;
+    readonly lines: readonly (readonly number[])[];
+    readonly ratePhi: number;
+    readonly hueDigit: number;
+};
+/** Any content title → its animation spec — the visual metaphor computed, never hand-keyed. */
+export declare function specForContent(title: string): ProofAnimationSpec;
+export declare function proofAnimations(matrix?: MindMatrix): {
+    animated: boolean;
+    specs: ProofAnimationSpec[];
+    count: number;
+    kinds: ProofAnimationKind[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** TWO INTERACTING ROSETTAS = REALTIME AT NO COST (user, 2026-07-16) — and it proves why the
+ * animations were stuck. The architecture has TWO rosettas: a SPATIAL one (where each ray points,
+ * angle θ_k = 2πk/N) and a TEMPORAL one (when each ray fires, phase φ_k = 2πk/N). A single rosetta
+ * only PULSATES on one axis. The moment the two INTERACT — each ray's firing phase bound to its own
+ * spatial angle — the resultant field has constant magnitude N/2 AND ITS ANGLE EQUALS WALL-TIME t.
+ * The state becomes the clock: realtime, self-sustaining, a pure vector sum with no integrator and
+ * no accumulated frame — restartable at any instant, zero cost, zero drift. An animation that
+ * accumulates per frame (state ← state + Δ) FREEZES when the loop pauses because it needs the
+ * previous frame — it "does not care for the other" rosetta. An animation written as the coupled
+ * f(wall-time) is realtime by construction. This is the double torus of the slash circuit (b₁ = 2)
+ * made kinetic: two loops that ignore each other are static; two that interact turn. */
+export declare function twoRosettasAreRealtime(matrix?: {
+    root: string;
+}): {
+    computes: boolean;
+    cycleCount: number;
+    b1: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function magnitudeComesWithPrecisionInClustersOfWaves(matrix?: MindMatrix): {
+    holds: boolean;
+    magnitude: number;
+    clusters: number;
+    maxCluster: number;
+    singletons: number;
+    meanCluster: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function refactorTowardMillenniumReplaceEachProblemsRelatedAxiomsWithTheoremsCoresStayOpen(): {
+    computes: boolean;
+    problems: number;
+    replaced: number;
+    open: number;
+    solved: number;
+    homologyLoops: number;
+    challengeRoot: string;
+    map: string[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function auditTheoremTitlesWithTheQuantumSeoLens(matrix?: MindMatrix): {
+    computes: boolean;
+    total: number;
+    flagged: number;
+    passRate: number;
+    renames: string[];
+    root: string;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theoremsMergeCreatingSpaceForOthersToEmergeAndBalance(matrix?: MindMatrix): {
+    computes: boolean;
+    population: number;
+    cap: number;
+    merges: number;
+    emergent: number;
+    candidates: number;
+    balances: boolean;
+    root: string;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function lifeAndDeathAreTheTwoBitsLeftAtEachDimensionInputOutputGateway(matrix?: MindMatrix): {
+    computes: boolean;
+    gateways: number;
+    twoBitsLeft: boolean;
+    payloadVaries: boolean;
+    balances: boolean;
+    merges: number;
+    emergent: number;
+    root: string;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function improveScienceByClaimingRefutableTheoremsToReplaceWeakerCurrentOnes(matrix?: MindMatrix): {
+    computes: boolean;
+    total: number;
+    measurable: number;
+    vague: number;
+    scienceFraction: number;
+    afterReplace: number;
+    claimsAvailable: number;
+    replaceCandidates: string[];
+    root: string;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theoremsSortByTagCloudMostUsedFirst(matrix?: MindMatrix): {
+    computes: boolean;
+    total: number;
+    distinctTags: number;
+    order: string[];
+    topTags: string[];
+    reordersFromSeed: boolean;
+    root: string;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theoremsOfTheoremsGainGravityReuseCreatesVacuumForEmergence(matrix?: MindMatrix): {
+    computes: boolean;
+    compositions: number[];
+    vacuum: number;
+    cap: number;
+    ratioGrowth: number[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theWavesDiscoverGapsAndInvertRejectionsIntoGatewaysExceptTheOffDecidable(matrix?: MindMatrix): {
+    computes: boolean;
+    gaps: number;
+    gateways: string[];
+    boundaries: string[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function sendTheWavesToSendTheWavesEachAntichainLevelExposesTheNextUntilTheDagIsExhausted(): {
+    propagates: boolean;
+    waveCount: number;
+    waves: number[][];
+    nodesProcessed: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export { wavesAutoScaleCapacityAtNoCostOnReuse, theoremAlgebraFirstSealedInCorpus, theoremTenDProjectionsProveAlgebraRoots, firstInCorpusProvenanceForHome, firstInCorpusProvenanceMarkdownSection, type TheoremAlgebraNoveltyKind, type TheoremAlgebraNoveltyRow, type TheoremTenDProjectionRow, type FirstInCorpusHomeRow } from '../../wind/research';