@justinelliottcobb/amari-wasm 0.19.1 → 0.21.0

package/amari_wasm.js

@@ -838,13 +838,31 @@ function getArrayF32FromWasm0(ptr, len) {
     return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 function __wbg_adapter_30(arg0, arg1, arg2) {
-    wasm.closure71_externref_shim(arg0, arg1, arg2);
+    wasm.closure72_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_965(arg0, arg1, arg2, arg3) {
-    wasm.closure65_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_1057(arg0, arg1, arg2, arg3) {
+    wasm.closure66_externref_shim(arg0, arg1, arg2, arg3);
 }
 
+/**
+ * Tie-handling policy for branch-sensitive dual-number min/max operations.
+ * @enum {0 | 1 | 2}
+ */
+export const WasmBranchPolicy = Object.freeze({
+    /**
+     * Preserve the left operand derivative on ties.
+     */
+    Left: 0, "0": "Left",
+    /**
+     * Preserve the right operand derivative on ties.
+     */
+    Right: 1, "1": "Right",
+    /**
+     * Average derivatives on ties.
+     */
+    Average: 2, "2": "Average",
+});
 /**
  * Integration methods available in WASM
  * @enum {0 | 1 | 2 | 3 | 4}
@@ -3030,6 +3048,28 @@ export class TropicalBatch {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_tropicalbatch_free(ptr, 0);
     }
+    /**
+     * Fold values with tropical addition (`max`).
+     * @param {Float64Array} values
+     * @returns {number}
+     */
+    static foldOplus(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tropicalbatch_batchTropicalAdd(ptr0, len0);
+        return ret;
+    }
+    /**
+     * Fold values with tropical multiplication (`+`).
+     * @param {Float64Array} values
+     * @returns {number}
+     */
+    static foldOtimes(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tropicalbatch_foldOtimes(ptr0, len0);
+        return ret;
+    }
     /**
      * Convert array of log probabilities to tropical numbers and find maximum
      * @param {Float64Array} log_probs
@@ -4651,6 +4691,28 @@ export class WasmDualNumber {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmdualnumber_free(ptr, 0);
     }
+    /**
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmDualNumber} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmDualNumber}
+     */
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmDualNumber);
+        const ret = wasm.wasmdualnumber_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmDualNumber.__wrap(ret);
+    }
+    /**
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmDualNumber} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmDualNumber}
+     */
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmDualNumber);
+        const ret = wasm.wasmdualnumber_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmDualNumber.__wrap(ret);
+    }
     /**
      * Natural logarithm
      * @returns {WasmDualNumber}
@@ -8574,6 +8636,34 @@ export class WasmMultiDualNumber {
         const ret = wasm.wasmmultidualnumber_getNumVars(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmMultiDualNumber} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmMultiDualNumber}
+     */
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmMultiDualNumber);
+        const ret = wasm.wasmmultidualnumber_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultiDualNumber.__wrap(ret[0]);
+    }
+    /**
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmMultiDualNumber} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmMultiDualNumber}
+     */
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmMultiDualNumber);
+        const ret = wasm.wasmmultidualnumber_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultiDualNumber.__wrap(ret[0]);
+    }
     /**
      * Addition
      * @param {WasmMultiDualNumber} other
@@ -8653,6 +8743,17 @@ export class WasmMultiDualNumber {
         const ret = wasm.wasmmultidualnumber_variable(value, num_vars, var_index);
         return WasmMultiDualNumber.__wrap(ret);
     }
+    /**
+     * Create one basis-seeded variable per input coordinate.
+     * @param {Float64Array} values
+     * @returns {Array<any>}
+     */
+    static variables(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmultidualnumber_variables(ptr0, len0);
+        return ret;
+    }
 }
 
 const WasmMultiObjectiveOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -9998,691 +10099,937 @@ export class WasmOptimizationUtils {
     }
 }
 
-const WasmParametricDensityFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmOrdinalFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmparametricdensity_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmordinal_free(ptr >>> 0, 1));
 /**
- * Parametric probability density families
+ * Arena-bound handle for an ordinal below ε₀.
  */
-export class WasmParametricDensity {
+export class WasmOrdinal {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmParametricDensity.prototype);
+        const obj = Object.create(WasmOrdinal.prototype);
         obj.__wbg_ptr = ptr;
-        WasmParametricDensityFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmOrdinalFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmParametricDensityFinalization.unregister(this);
+        WasmOrdinalFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmparametricdensity_free(ptr, 0);
+        wasm.__wbg_wasmordinal_free(ptr, 0);
     }
     /**
-     * Create an Exponential density Exp(λ)
-     * @returns {WasmParametricDensity}
+     * Raw arena-local ordinal index.
+     * @returns {number}
      */
-    static exponential() {
-        const ret = wasm.wasmparametricdensity_exponential();
-        return WasmParametricDensity.__wrap(ret);
+    getIndex() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
+const WasmOrdinalArenaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmordinalarena_free(ptr >>> 0, 1));
+/**
+ * Arena-backed store for canonical ordinals below ε₀.
+ */
+export class WasmOrdinalArena {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmOrdinalArenaFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmordinalarena_free(ptr, 0);
     }
     /**
-     * Compute log-density log p(x|θ)
-     * @param {number} x
-     * @param {Float64Array} params
+     * Number of interned ordinal nodes.
      * @returns {number}
      */
-    logDensity(x, params) {
-        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmparametricdensity_logDensity(this.__wbg_ptr, x, ptr0, len0);
+    nodeCount() {
+        const ret = wasm.wasmordinalarena_nodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of CNF terms.
+     * @param {WasmOrdinal} ordinal
+     * @returns {number}
+     */
+    termCount(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_termCount(this.__wbg_ptr, ordinal.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0];
+        return ret[0] >>> 0;
     }
     /**
-     * Compute Fisher information matrix from data samples
-     * @param {Float64Array} data
-     * @param {Float64Array} params
-     * @returns {Float64Array}
+     * Select the best of two weights using semiring-style `max`.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
+     * @returns {WasmOrdinalWeight}
      */
-    fisherInformation(data, params) {
-        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmparametricdensity_fisherInformation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    bestWeight2(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_bestWeight2(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
     /**
-     * Create a Cauchy density Cauchy(x₀, γ)
-     * @returns {WasmParametricDensity}
+     * Select the best of three weights using semiring-style `max`.
+     * @param {WasmOrdinalWeight} first
+     * @param {WasmOrdinalWeight} second
+     * @param {WasmOrdinalWeight} third
+     * @returns {WasmOrdinalWeight}
      */
-    static cauchy() {
-        const ret = wasm.wasmparametricdensity_cauchy();
-        return WasmParametricDensity.__wrap(ret);
+    bestWeight3(first, second, third) {
+        _assertClass(first, WasmOrdinalWeight);
+        _assertClass(second, WasmOrdinalWeight);
+        _assertClass(third, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_bestWeight3(this.__wbg_ptr, first.__wbg_ptr, second.__wbg_ptr, third.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
     /**
-     * Create a Laplace density Laplace(μ, b)
-     * @returns {WasmParametricDensity}
+     * Finite value when the ordinal is finite.
+     * @param {WasmOrdinal} ordinal
+     * @returns {number | undefined}
      */
-    static laplace() {
-        const ret = wasm.wasmparametricdensity_laplace();
-        return WasmParametricDensity.__wrap(ret);
+    finiteValue(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_finiteValue(this.__wbg_ptr, ordinal.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
     }
     /**
-     * Evaluate density at point x with parameters
-     *
-     * # Arguments
-     * * `x` - Point to evaluate
-     * * `params` - Parameters (Gaussian: [μ, σ], Exponential: [λ], etc.)
-     * @param {number} x
-     * @param {Float64Array} params
-     * @returns {number}
+     * Return true if this is a successor ordinal.
+     * @param {WasmOrdinal} ordinal
+     * @returns {boolean}
      */
-    evaluate(x, params) {
-        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmparametricdensity_evaluate(this.__wbg_ptr, x, ptr0, len0);
+    isSuccessor(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_isSuccessor(this.__wbg_ptr, ordinal.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0];
+        return ret[0] !== 0;
     }
     /**
-     * Create a Gaussian density N(μ, σ²)
-     * @returns {WasmParametricDensity}
+     * Semiring-style additive combination (`max`) for ordinal weights.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
+     * @returns {WasmOrdinalWeight}
      */
-    static gaussian() {
-        const ret = wasm.wasmparametricdensity_gaussian();
-        return WasmParametricDensity.__wrap(ret);
+    oplusWeight(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_oplusWeight(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
     /**
-     * Compute numerical gradient ∇_θ p(x|θ)
-     * @param {number} x
-     * @param {Float64Array} params
-     * @returns {Float64Array}
+     * Format an ordinal weight.
+     * @param {WasmOrdinalWeight} weight
+     * @returns {string}
      */
-    gradient(x, params) {
-        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmparametricdensity_gradient(this.__wbg_ptr, x, ptr0, len0);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    formatWeight(weight) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(weight, WasmOrdinalWeight);
+            const ret = wasm.wasmordinalarena_formatWeight(this.__wbg_ptr, weight.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
-        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v2;
     }
-}
-
-const WasmPartitionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpartition_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for partitions used in Schubert calculus and LR coefficients
- */
-export class WasmPartition {
-
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof WasmPartition)) {
-            return 0;
+    /**
+     * Semiring-style multiplicative composition (ordinal addition) for weights.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
+     * @returns {WasmOrdinalWeight}
+     */
+    otimesWeight(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_otimesWeight(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        return jsValue.__destroy_into_raw();
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmPartitionFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmpartition_free(ptr, 0);
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
     /**
-     * Get the length (number of non-zero parts) of this partition
+     * Compare two weights: -1 for less, 0 for equal, 1 for greater.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
      * @returns {number}
      */
-    getLength() {
-        const ret = wasm.wasmopticalrotorfield_length(this.__wbg_ptr);
-        return ret >>> 0;
+    compareWeight(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_compareWeight(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
     /**
-     * Check if this partition fits in a k × (n-k) box (for Grassmannian)
-     * @param {number} k
-     * @param {number} n
-     * @returns {boolean}
+     * Format an ordinal in Cantor normal form.
+     * @param {WasmOrdinal} ordinal
+     * @returns {string}
      */
-    fitsInBox(k, n) {
-        const ret = wasm.wasmpartition_fitsInBox(this.__wbg_ptr, k, n);
-        return ret !== 0;
+    formatOrdinal(ordinal) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(ordinal, WasmOrdinal);
+            const ret = wasm.wasmordinalarena_formatOrdinal(this.__wbg_ptr, ordinal.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
     }
     /**
-     * Create a new partition from an array of parts
-     * @param {Uint32Array} parts
+     * Compose two weights using ordinal addition with bottom annihilation.
+     * @param {WasmOrdinalWeight} left
+     * @param {WasmOrdinalWeight} right
+     * @returns {WasmOrdinalWeight}
      */
-    constructor(parts) {
-        const ptr0 = passArray32ToWasm0(parts, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmpartition_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        WasmPartitionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    composeWeight2(left, right) {
+        _assertClass(left, WasmOrdinalWeight);
+        _assertClass(right, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_composeWeight2(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
     /**
-     * Check if this partition contains another (for skew shapes)
-     * @param {WasmPartition} other
-     * @returns {boolean}
+     * Compose three weights using ordinal addition with bottom annihilation.
+     * @param {WasmOrdinalWeight} first
+     * @param {WasmOrdinalWeight} second
+     * @param {WasmOrdinalWeight} third
+     * @returns {WasmOrdinalWeight}
      */
-    contains(other) {
-        _assertClass(other, WasmPartition);
-        const ret = wasm.wasmpartition_contains(this.__wbg_ptr, other.__wbg_ptr);
-        return ret !== 0;
+    composeWeight3(first, second, third) {
+        _assertClass(first, WasmOrdinalWeight);
+        _assertClass(second, WasmOrdinalWeight);
+        _assertClass(third, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_composeWeight3(this.__wbg_ptr, first.__wbg_ptr, second.__wbg_ptr, third.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinalWeight.__wrap(ret[0]);
     }
     /**
-     * Get the size (sum of parts) of this partition
-     * @returns {number}
+     * Build a JavaScript object with ordinal inspection metadata.
+     * @param {WasmOrdinal} ordinal
+     * @returns {any}
      */
-    getSize() {
-        const ret = wasm.wasmpartition_getSize(this.__wbg_ptr);
-        return ret >>> 0;
+    inspectOrdinal(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_inspectOrdinal(this.__wbg_ptr, ordinal.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Check if this partition is valid (weakly decreasing, positive parts)
+     * Return true if the ordinal is zero.
+     * @param {WasmOrdinal} ordinal
      * @returns {boolean}
      */
-    isValid() {
-        const ret = wasm.wasmpartition_isValid(this.__wbg_ptr);
-        return ret !== 0;
+    isZeroOrdinal(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_isZeroOrdinal(this.__wbg_ptr, ordinal.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
     }
     /**
-     * Get the parts of this partition
-     * @returns {Uint32Array}
+     * Construct a weight from an ordinal.
+     * @param {WasmOrdinal} ordinal
+     * @returns {WasmOrdinalWeight}
      */
-    getParts() {
-        const ret = wasm.wasmpartition_getParts(this.__wbg_ptr);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    weightFromOrdinal(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_weightFromOrdinal(this.__wbg_ptr, ordinal.__wbg_ptr);
+        return WasmOrdinalWeight.__wrap(ret);
     }
-}
-
-const WasmPersistentHomologyFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpersistenthomology_free(ptr >>> 0, 1));
-/**
- * Result of persistent homology computation.
- */
-export class WasmPersistentHomology {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmPersistentHomology.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmPersistentHomologyFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+    /**
+     * Ordinal addition.
+     * @param {WasmOrdinal} left
+     * @param {WasmOrdinal} right
+     * @returns {WasmOrdinal}
+     */
+    add(left, right) {
+        _assertClass(left, WasmOrdinal);
+        _assertClass(right, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_add(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOrdinal.__wrap(ret[0]);
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmPersistentHomologyFinalization.unregister(this);
-        return ptr;
+    /**
+     * Create an ordinal arena containing zero.
+     */
+    constructor() {
+        const ret = wasm.wasmordinalarena_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmOrdinalArenaFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmpersistenthomology_free(ptr, 0);
+    /**
+     * Finite ordinal one.
+     * @returns {WasmOrdinal}
+     */
+    one() {
+        const ret = wasm.wasmordinalarena_one(this.__wbg_ptr);
+        return WasmOrdinal.__wrap(ret);
     }
     /**
-     * Get the persistence diagram as an array of [dimension, birth, death] triples.
-     * @returns {Float64Array}
+     * Structural kind: zero, finite, successor, or limit.
+     * @param {WasmOrdinal} ordinal
+     * @returns {string}
      */
-    getDiagram() {
-        const ret = wasm.wasmpersistenthomology_getDiagram(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    kind(ordinal) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(ordinal, WasmOrdinal);
+            const ret = wasm.wasmordinalarena_kind(this.__wbg_ptr, ordinal.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
     }
     /**
-     * Get the number of intervals in dimension k.
-     * @param {number} dim
+     * Canonical zero ordinal.
+     * @returns {WasmOrdinal}
+     */
+    zero() {
+        const ret = wasm.wasmordinalarena_zero(this.__wbg_ptr);
+        return WasmOrdinal.__wrap(ret);
+    }
+    /**
+     * The ordinal ω.
+     * @returns {WasmOrdinal}
+     */
+    omega() {
+        const ret = wasm.wasmordinalarena_omega(this.__wbg_ptr);
+        return WasmOrdinal.__wrap(ret);
+    }
+    /**
+     * Finite natural ordinal `n`.
+     * @param {number} n
+     * @returns {WasmOrdinal}
+     */
+    finite(n) {
+        const ret = wasm.wasmordinalarena_finite(this.__wbg_ptr, n);
+        return WasmOrdinal.__wrap(ret);
+    }
+    /**
+     * Compare two ordinals: -1 for less, 0 for equal, 1 for greater.
+     * @param {WasmOrdinal} left
+     * @param {WasmOrdinal} right
      * @returns {number}
      */
-    intervalCount(dim) {
-        const ret = wasm.wasmpersistenthomology_intervalCount(this.__wbg_ptr, dim);
-        return ret >>> 0;
+    compare(left, right) {
+        _assertClass(left, WasmOrdinal);
+        _assertClass(right, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_compare(this.__wbg_ptr, left.__wbg_ptr, right.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
     /**
-     * Compute persistent homology from a filtration.
-     * @param {WasmFiltration} filtration
-     * @returns {WasmPersistentHomology}
+     * Return true if this is a nonzero limit ordinal.
+     * @param {WasmOrdinal} ordinal
+     * @returns {boolean}
      */
-    static compute(filtration) {
-        _assertClass(filtration, WasmFiltration);
-        const ret = wasm.wasmpersistenthomology_compute(filtration.__wbg_ptr);
+    isLimit(ordinal) {
+        _assertClass(ordinal, WasmOrdinal);
+        const ret = wasm.wasmordinalarena_isLimit(this.__wbg_ptr, ordinal.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return WasmPersistentHomology.__wrap(ret[0]);
+        return ret[0] !== 0;
     }
     /**
-     * Get the Betti numbers at a specific filtration time.
-     * @param {number} time
-     * @returns {Uint32Array}
+     * Leading-exponent valuation of a weight, if any.
+     * @param {WasmOrdinalWeight} weight
+     * @returns {number | undefined}
      */
-    bettiAt(time) {
-        const ret = wasm.wasmpersistenthomology_bettiAt(this.__wbg_ptr, time);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    valuation(weight) {
+        _assertClass(weight, WasmOrdinalWeight);
+        const ret = wasm.wasmordinalarena_valuation(this.__wbg_ptr, weight.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0x100000001 ? undefined : ret[0];
     }
 }
 
-const WasmProbFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmOrdinalWeightFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprob_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmordinalweight_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for probabilistic values
- *
- * Wraps an f64 value with associated probability metadata.
- * Supports mapping, composition, and probability tracking.
+ * Bottom-extended ordinal optimization weight.
  */
-export class WasmProb {
+export class WasmOrdinalWeight {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmProb.prototype);
+        const obj = Object.create(WasmOrdinalWeight.prototype);
         obj.__wbg_ptr = ptr;
-        WasmProbFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmOrdinalWeightFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmProbFinalization.unregister(this);
+        WasmOrdinalWeightFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmprob_free(ptr, 0);
-    }
-    /**
-     * Get the probability associated with this value
-     * @returns {number}
-     */
-    probability() {
-        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Create a value with specified probability
-     *
-     * Probability must be in [0, 1].
-     * @param {number} probability
-     * @param {number} value
-     * @returns {WasmProb}
-     */
-    static withProbability(probability, value) {
-        const ret = wasm.wasmprob_withProbability(probability, value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmProb.__wrap(ret[0]);
+        wasm.__wbg_wasmordinalweight_free(ptr, 0);
     }
     /**
-     * Map the value by multiplying with a factor, preserving probability
-     * @param {number} factor
-     * @returns {WasmProb}
+     * Arena-local ordinal index when this weight wraps an ordinal.
+     * @returns {number | undefined}
      */
-    map(factor) {
-        const ret = wasm.wasmprob_map(this.__wbg_ptr, factor);
-        return WasmProb.__wrap(ret);
+    ordinalIndex() {
+        const ret = wasm.wasmordinalweight_ordinalIndex(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
     }
     /**
-     * Create a certain value (probability = 1.0)
-     * @param {number} value
+     * Construct the semiring one element, i.e. ordinal zero.
+     * @returns {WasmOrdinalWeight}
      */
-    constructor(value) {
-        const ret = wasm.wasmdualnumber_variable(value);
-        this.__wbg_ptr = ret >>> 0;
-        WasmProbFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    static one() {
+        const ret = wasm.wasmordinalweight_one();
+        return WasmOrdinalWeight.__wrap(ret);
     }
     /**
-     * Get the wrapped value
-     * @returns {number}
+     * Alias for the semiring zero element.
+     * @returns {WasmOrdinalWeight}
      */
-    value() {
-        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
-        return ret;
+    static zero() {
+        const ret = wasm.wasmordinalweight_bottom();
+        return WasmOrdinalWeight.__wrap(ret);
     }
     /**
-     * Sample this probabilistic value
-     *
-     * Returns the value with probability p, or NaN otherwise.
-     * @returns {number}
+     * Construct the bottom element.
+     * @returns {WasmOrdinalWeight}
      */
-    sample() {
-        const ret = wasm.wasmprob_sample(this.__wbg_ptr);
-        return ret;
+    static bottom() {
+        const ret = wasm.wasmordinalweight_bottom();
+        return WasmOrdinalWeight.__wrap(ret);
     }
     /**
-     * Combine with another probabilistic value (independent)
-     *
-     * Multiplies probabilities and values together.
-     * @param {number} other_probability
-     * @param {number} other_value
-     * @returns {WasmProb}
+     * Whether this weight is bottom.
+     * @returns {boolean}
      */
-    andThen(other_probability, other_value) {
-        const ret = wasm.wasmprob_andThen(this.__wbg_ptr, other_probability, other_value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmProb.__wrap(ret[0]);
+    isBottom() {
+        const ret = wasm.wasmordinalweight_isBottom(this.__wbg_ptr);
+        return ret !== 0;
     }
 }
 
-const WasmProbabilityMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmParametricDensityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprobabilitymeasure_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmparametricdensity_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for probability measures
- *
- * A probability measure assigns total measure 1 to the entire space.
+ * Parametric probability density families
  */
-export class WasmProbabilityMeasure {
+export class WasmParametricDensity {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmProbabilityMeasure.prototype);
+        const obj = Object.create(WasmParametricDensity.prototype);
         obj.__wbg_ptr = ptr;
-        WasmProbabilityMeasureFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmParametricDensityFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmProbabilityMeasureFinalization.unregister(this);
+        WasmParametricDensityFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmprobabilitymeasure_free(ptr, 0);
+        wasm.__wbg_wasmparametricdensity_free(ptr, 0);
     }
     /**
-     * Get a description of this probability measure
-     * @returns {string}
+     * Create an Exponential density Exp(λ)
+     * @returns {WasmParametricDensity}
      */
-    getDescription() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.wasmprobabilitymeasure_getDescription(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
+    static exponential() {
+        const ret = wasm.wasmparametricdensity_exponential();
+        return WasmParametricDensity.__wrap(ret);
     }
     /**
-     * Compute P(X ∈ [a, b]) for uniform distribution
-     * @param {number} a
-     * @param {number} b
-     * @param {number} lower
-     * @param {number} upper
+     * Compute log-density log p(x|θ)
+     * @param {number} x
+     * @param {Float64Array} params
      * @returns {number}
      */
-    probabilityInterval(a, b, lower, upper) {
-        const ret = wasm.wasmprobabilitymeasure_probabilityInterval(this.__wbg_ptr, a, b, lower, upper);
-        return ret;
+    logDensity(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_logDensity(this.__wbg_ptr, x, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
     /**
-     * Create a new uniform probability measure on [0, 1]
+     * Compute Fisher information matrix from data samples
+     * @param {Float64Array} data
+     * @param {Float64Array} params
+     * @returns {Float64Array}
      */
-    constructor() {
-        const ret = wasm.wasmprobabilitymeasure_new();
-        this.__wbg_ptr = ret >>> 0;
-        WasmProbabilityMeasureFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    fisherInformation(data, params) {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_fisherInformation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
     }
     /**
-     * Create a uniform probability measure on [a, b]
-     * @param {number} a
-     * @param {number} b
-     * @returns {WasmProbabilityMeasure}
+     * Create a Cauchy density Cauchy(x₀, γ)
+     * @returns {WasmParametricDensity}
      */
-    static uniform(a, b) {
-        const ret = wasm.wasmprobabilitymeasure_uniform(a, b);
+    static cauchy() {
+        const ret = wasm.wasmparametricdensity_cauchy();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Create a Laplace density Laplace(μ, b)
+     * @returns {WasmParametricDensity}
+     */
+    static laplace() {
+        const ret = wasm.wasmparametricdensity_laplace();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Evaluate density at point x with parameters
+     *
+     * # Arguments
+     * * `x` - Point to evaluate
+     * * `params` - Parameters (Gaussian: [μ, σ], Exponential: [λ], etc.)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {number}
+     */
+    evaluate(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_evaluate(this.__wbg_ptr, x, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return WasmProbabilityMeasure.__wrap(ret[0]);
+        return ret[0];
+    }
+    /**
+     * Create a Gaussian density N(μ, σ²)
+     * @returns {WasmParametricDensity}
+     */
+    static gaussian() {
+        const ret = wasm.wasmparametricdensity_gaussian();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Compute numerical gradient ∇_θ p(x|θ)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {Float64Array}
+     */
+    gradient(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_gradient(this.__wbg_ptr, x, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
     }
 }
 
-const WasmProjectiveSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmPartitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprojectivespace_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpartition_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for projective spaces
+ * WASM wrapper for partitions used in Schubert calculus and LR coefficients
  */
-export class WasmProjectiveSpace {
+export class WasmPartition {
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof WasmPartition)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmProjectiveSpaceFinalization.unregister(this);
+        WasmPartitionFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmprojectivespace_free(ptr, 0);
+        wasm.__wbg_wasmpartition_free(ptr, 0);
     }
     /**
-     * Get the dimension of this projective space
+     * Get the length (number of non-zero parts) of this partition
      * @returns {number}
      */
-    getDimension() {
-        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+    getLength() {
+        const ret = wasm.wasmopticalrotorfield_length(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Check if the projective space has given dimension
-     * @param {number} dim
+     * Check if this partition fits in a k × (n-k) box (for Grassmannian)
+     * @param {number} k
+     * @param {number} n
      * @returns {boolean}
      */
-    hasDimension(dim) {
-        const ret = wasm.wasmprojectivespace_hasDimension(this.__wbg_ptr, dim);
+    fitsInBox(k, n) {
+        const ret = wasm.wasmpartition_fitsInBox(this.__wbg_ptr, k, n);
         return ret !== 0;
     }
     /**
-     * Compute Bézout intersection number for two curves
-     * @param {number} degree1
-     * @param {number} degree2
+     * Create a new partition from an array of parts
+     * @param {Uint32Array} parts
+     */
+    constructor(parts) {
+        const ptr0 = passArray32ToWasm0(parts, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpartition_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        WasmPartitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Check if this partition contains another (for skew shapes)
+     * @param {WasmPartition} other
+     * @returns {boolean}
+     */
+    contains(other) {
+        _assertClass(other, WasmPartition);
+        const ret = wasm.wasmpartition_contains(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the size (sum of parts) of this partition
      * @returns {number}
      */
-    bezoutIntersection(degree1, degree2) {
-        const ret = wasm.wasmprojectivespace_bezoutIntersection(this.__wbg_ptr, degree1, degree2);
-        return ret;
+    getSize() {
+        const ret = wasm.wasmpartition_getSize(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Create a new projective space of given dimension
-     * @param {number} dimension
+     * Check if this partition is valid (weakly decreasing, positive parts)
+     * @returns {boolean}
      */
-    constructor(dimension) {
-        const ret = wasm.wasmmontecarloverifier_new(dimension);
-        this.__wbg_ptr = ret >>> 0;
-        WasmProjectiveSpaceFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    isValid() {
+        const ret = wasm.wasmpartition_isValid(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the parts of this partition
+     * @returns {Uint32Array}
+     */
+    getParts() {
+        const ret = wasm.wasmpartition_getParts(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
 }
 
-const WasmPropagationAnalysisFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmPersistentHomologyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpropagationanalysis_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpersistenthomology_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for propagation analysis
+ * Result of persistent homology computation.
  */
-export class WasmPropagationAnalysis {
+export class WasmPersistentHomology {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmPropagationAnalysis.prototype);
+        const obj = Object.create(WasmPersistentHomology.prototype);
         obj.__wbg_ptr = ptr;
-        WasmPropagationAnalysisFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmPersistentHomologyFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmPropagationAnalysisFinalization.unregister(this);
+        WasmPersistentHomologyFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmpropagationanalysis_free(ptr, 0);
+        wasm.__wbg_wasmpersistenthomology_free(ptr, 0);
     }
     /**
-     * Get convergence time
+     * Get the persistence diagram as an array of [dimension, birth, death] triples.
+     * @returns {Float64Array}
+     */
+    getDiagram() {
+        const ret = wasm.wasmpersistenthomology_getDiagram(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the number of intervals in dimension k.
+     * @param {number} dim
      * @returns {number}
      */
-    get convergenceTime() {
-        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
+    intervalCount(dim) {
+        const ret = wasm.wasmpersistenthomology_intervalCount(this.__wbg_ptr, dim);
         return ret >>> 0;
     }
     /**
-     * Get influence scores for each node
-     * @returns {Float64Array}
+     * Compute persistent homology from a filtration.
+     * @param {WasmFiltration} filtration
+     * @returns {WasmPersistentHomology}
      */
-    get influenceScores() {
-        const ret = wasm.wasmpropagationanalysis_influence_scores(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    static compute(filtration) {
+        _assertClass(filtration, WasmFiltration);
+        const ret = wasm.wasmpersistenthomology_compute(filtration.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmPersistentHomology.__wrap(ret[0]);
     }
     /**
-     * Get coverage over time
+     * Get the Betti numbers at a specific filtration time.
+     * @param {number} time
      * @returns {Uint32Array}
      */
-    get coverage() {
-        const ret = wasm.wasmpropagationanalysis_coverage(this.__wbg_ptr);
+    bettiAt(time) {
+        const ret = wasm.wasmpersistenthomology_bettiAt(this.__wbg_ptr, time);
         var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
 }
 
-const WasmRareEventFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmProbFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrareevent_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprob_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for rare event tracking
+ * WASM wrapper for probabilistic values
  *
- * Represents events with low but non-zero probability,
- * distinguished from impossible events (P=0).
+ * Wraps an f64 value with associated probability metadata.
+ * Supports mapping, composition, and probability tracking.
  */
-export class WasmRareEvent {
+export class WasmProb {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmProb.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmProbFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmRareEventFinalization.unregister(this);
+        WasmProbFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmrareevent_free(ptr, 0);
+        wasm.__wbg_wasmprob_free(ptr, 0);
     }
     /**
-     * Get the event description
-     * @returns {string}
-     */
-    description() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.wasmrareevent_description(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * Get the probability of this rare event
-     * @returns {number}
+     * Get the probability associated with this value
+     * @returns {number}
      */
     probability() {
-        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Create a rare event with given probability and description
+     * Create a value with specified probability
      *
-     * Probability must be in (0, 1).
+     * Probability must be in [0, 1].
      * @param {number} probability
-     * @param {string} description
+     * @param {number} value
+     * @returns {WasmProb}
      */
-    constructor(probability, description) {
-        const ptr0 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmrareevent_new(probability, ptr0, len0);
+    static withProbability(probability, value) {
+        const ret = wasm.wasmprob_withProbability(probability, value);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        WasmRareEventFinalization.register(this, this.__wbg_ptr, this);
+        return WasmProb.__wrap(ret[0]);
+    }
+    /**
+     * Map the value by multiplying with a factor, preserving probability
+     * @param {number} factor
+     * @returns {WasmProb}
+     */
+    map(factor) {
+        const ret = wasm.wasmprob_map(this.__wbg_ptr, factor);
+        return WasmProb.__wrap(ret);
+    }
+    /**
+     * Create a certain value (probability = 1.0)
+     * @param {number} value
+     */
+    constructor(value) {
+        const ret = wasm.wasmdualnumber_variable(value);
+        this.__wbg_ptr = ret >>> 0;
+        WasmProbFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Check if this event is rare (probability < threshold)
-     * @param {number} threshold
-     * @returns {boolean}
+     * Get the wrapped value
+     * @returns {number}
      */
-    isRare(threshold) {
-        const ret = wasm.wasmrareevent_isRare(this.__wbg_ptr, threshold);
-        return ret !== 0;
+    value() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Classify event based on probability with the given rare threshold
+     * Sample this probabilistic value
      *
-     * Returns "Impossible" (P=0), "Rare" (P < threshold), or "Probable" (P >= threshold)
-     * @param {number} rare_threshold
+     * Returns the value with probability p, or NaN otherwise.
+     * @returns {number}
+     */
+    sample() {
+        const ret = wasm.wasmprob_sample(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Combine with another probabilistic value (independent)
+     *
+     * Multiplies probabilities and values together.
+     * @param {number} other_probability
+     * @param {number} other_value
+     * @returns {WasmProb}
+     */
+    andThen(other_probability, other_value) {
+        const ret = wasm.wasmprob_andThen(this.__wbg_ptr, other_probability, other_value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmProb.__wrap(ret[0]);
+    }
+}
+
+const WasmProbabilityMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprobabilitymeasure_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for probability measures
+ *
+ * A probability measure assigns total measure 1 to the entire space.
+ */
+export class WasmProbabilityMeasure {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmProbabilityMeasure.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmProbabilityMeasureFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmProbabilityMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmprobabilitymeasure_free(ptr, 0);
+    }
+    /**
+     * Get a description of this probability measure
      * @returns {string}
      */
-    classify(rare_threshold) {
+    getDescription() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.wasmrareevent_classify(this.__wbg_ptr, rare_threshold);
+            const ret = wasm.wasmprobabilitymeasure_getDescription(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -10690,116 +11037,359 @@ export class WasmRareEvent {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Compute P(X ∈ [a, b]) for uniform distribution
+     * @param {number} a
+     * @param {number} b
+     * @param {number} lower
+     * @param {number} upper
+     * @returns {number}
+     */
+    probabilityInterval(a, b, lower, upper) {
+        const ret = wasm.wasmprobabilitymeasure_probabilityInterval(this.__wbg_ptr, a, b, lower, upper);
+        return ret;
+    }
+    /**
+     * Create a new uniform probability measure on [0, 1]
+     */
+    constructor() {
+        const ret = wasm.wasmprobabilitymeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmProbabilityMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a uniform probability measure on [a, b]
+     * @param {number} a
+     * @param {number} b
+     * @returns {WasmProbabilityMeasure}
+     */
+    static uniform(a, b) {
+        const ret = wasm.wasmprobabilitymeasure_uniform(a, b);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmProbabilityMeasure.__wrap(ret[0]);
+    }
 }
 
-const WasmRelativisticConstantsFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmProjectiveSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrelativisticconstants_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprojectivespace_free(ptr >>> 0, 1));
 /**
- * Physical constants
+ * WASM wrapper for projective spaces
  */
-export class WasmRelativisticConstants {
+export class WasmProjectiveSpace {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmRelativisticConstantsFinalization.unregister(this);
+        WasmProjectiveSpaceFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmrelativisticconstants_free(ptr, 0);
+        wasm.__wbg_wasmprojectivespace_free(ptr, 0);
     }
     /**
-     * Earth mass (kg)
+     * Get the dimension of this projective space
      * @returns {number}
      */
-    static get earth_mass() {
-        const ret = wasm.wasmrelativisticconstants_earth_mass();
-        return ret;
+    getDimension() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Solar mass (kg)
-     * @returns {number}
+     * Check if the projective space has given dimension
+     * @param {number} dim
+     * @returns {boolean}
      */
-    static get solar_mass() {
-        const ret = wasm.wasmrelativisticconstants_solar_mass();
-        return ret;
+    hasDimension(dim) {
+        const ret = wasm.wasmprojectivespace_hasDimension(this.__wbg_ptr, dim);
+        return ret !== 0;
     }
     /**
-     * Speed of light in vacuum (m/s)
+     * Compute Bézout intersection number for two curves
+     * @param {number} degree1
+     * @param {number} degree2
      * @returns {number}
      */
-    static get speed_of_light() {
-        const ret = wasm.wasmrelativisticconstants_speed_of_light();
+    bezoutIntersection(degree1, degree2) {
+        const ret = wasm.wasmprojectivespace_bezoutIntersection(this.__wbg_ptr, degree1, degree2);
         return ret;
     }
     /**
-     * Gravitational constant (m³/kg·s²)
-     * @returns {number}
+     * Create a new projective space of given dimension
+     * @param {number} dimension
      */
-    static get gravitational_constant() {
-        const ret = wasm.wasmrelativisticconstants_gravitational_constant();
-        return ret;
+    constructor(dimension) {
+        const ret = wasm.wasmmontecarloverifier_new(dimension);
+        this.__wbg_ptr = ret >>> 0;
+        WasmProjectiveSpaceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
 }
 
-const WasmRelativisticParticleFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmPropagationAnalysisFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrelativisticparticle_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpropagationanalysis_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for relativistic particles
+ * WASM wrapper for propagation analysis
  */
-export class WasmRelativisticParticle {
+export class WasmPropagationAnalysis {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmRelativisticParticle.prototype);
+        const obj = Object.create(WasmPropagationAnalysis.prototype);
         obj.__wbg_ptr = ptr;
-        WasmRelativisticParticleFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmPropagationAnalysisFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmRelativisticParticleFinalization.unregister(this);
+        WasmPropagationAnalysisFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmrelativisticparticle_free(ptr, 0);
+        wasm.__wbg_wasmpropagationanalysis_free(ptr, 0);
     }
     /**
-     * Get 3D position components
-     * @returns {Array<any>}
+     * Get convergence time
+     * @returns {number}
      */
-    position_3d() {
-        const ret = wasm.wasmrelativisticparticle_position_3d(this.__wbg_ptr);
-        return ret;
+    get convergenceTime() {
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Get position as spacetime vector
-     * @returns {WasmSpacetimeVector}
+     * Get influence scores for each node
+     * @returns {Float64Array}
      */
-    position_4d() {
-        const ret = wasm.wasmrelativisticparticle_position_4d(this.__wbg_ptr);
-        return WasmSpacetimeVector.__wrap(ret);
+    get influenceScores() {
+        const ret = wasm.wasmpropagationanalysis_influence_scores(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * Create particle with specified energy
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {number} direction_x
-     * @param {number} direction_y
-     * @param {number} direction_z
-     * @param {number} kinetic_energy
-     * @param {number} mass
-     * @param {number} charge
-     * @returns {WasmRelativisticParticle}
+     * Get coverage over time
+     * @returns {Uint32Array}
+     */
+    get coverage() {
+        const ret = wasm.wasmpropagationanalysis_coverage(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+
+const WasmRareEventFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrareevent_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for rare event tracking
+ *
+ * Represents events with low but non-zero probability,
+ * distinguished from impossible events (P=0).
+ */
+export class WasmRareEvent {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRareEventFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmrareevent_free(ptr, 0);
+    }
+    /**
+     * Get the event description
+     * @returns {string}
+     */
+    description() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmrareevent_description(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the probability of this rare event
+     * @returns {number}
+     */
+    probability() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a rare event with given probability and description
+     *
+     * Probability must be in (0, 1).
+     * @param {number} probability
+     * @param {string} description
+     */
+    constructor(probability, description) {
+        const ptr0 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmrareevent_new(probability, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmRareEventFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Check if this event is rare (probability < threshold)
+     * @param {number} threshold
+     * @returns {boolean}
+     */
+    isRare(threshold) {
+        const ret = wasm.wasmrareevent_isRare(this.__wbg_ptr, threshold);
+        return ret !== 0;
+    }
+    /**
+     * Classify event based on probability with the given rare threshold
+     *
+     * Returns "Impossible" (P=0), "Rare" (P < threshold), or "Probable" (P >= threshold)
+     * @param {number} rare_threshold
+     * @returns {string}
+     */
+    classify(rare_threshold) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmrareevent_classify(this.__wbg_ptr, rare_threshold);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const WasmRelativisticConstantsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrelativisticconstants_free(ptr >>> 0, 1));
+/**
+ * Physical constants
+ */
+export class WasmRelativisticConstants {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRelativisticConstantsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmrelativisticconstants_free(ptr, 0);
+    }
+    /**
+     * Earth mass (kg)
+     * @returns {number}
+     */
+    static get earth_mass() {
+        const ret = wasm.wasmrelativisticconstants_earth_mass();
+        return ret;
+    }
+    /**
+     * Solar mass (kg)
+     * @returns {number}
+     */
+    static get solar_mass() {
+        const ret = wasm.wasmrelativisticconstants_solar_mass();
+        return ret;
+    }
+    /**
+     * Speed of light in vacuum (m/s)
+     * @returns {number}
+     */
+    static get speed_of_light() {
+        const ret = wasm.wasmrelativisticconstants_speed_of_light();
+        return ret;
+    }
+    /**
+     * Gravitational constant (m³/kg·s²)
+     * @returns {number}
+     */
+    static get gravitational_constant() {
+        const ret = wasm.wasmrelativisticconstants_gravitational_constant();
+        return ret;
+    }
+}
+
+const WasmRelativisticParticleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrelativisticparticle_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for relativistic particles
+ */
+export class WasmRelativisticParticle {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmRelativisticParticle.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRelativisticParticleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRelativisticParticleFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmrelativisticparticle_free(ptr, 0);
+    }
+    /**
+     * Get 3D position components
+     * @returns {Array<any>}
+     */
+    position_3d() {
+        const ret = wasm.wasmrelativisticparticle_position_3d(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get position as spacetime vector
+     * @returns {WasmSpacetimeVector}
+     */
+    position_4d() {
+        const ret = wasm.wasmrelativisticparticle_position_4d(this.__wbg_ptr);
+        return WasmSpacetimeVector.__wrap(ret);
+    }
+    /**
+     * Create particle with specified energy
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @param {number} kinetic_energy
+     * @param {number} mass
+     * @param {number} charge
+     * @returns {WasmRelativisticParticle}
      */
     static with_energy(x, y, z, direction_x, direction_y, direction_z, kinetic_energy, mass, charge) {
         const ret = wasm.wasmrelativisticparticle_with_energy(x, y, z, direction_x, direction_y, direction_z, kinetic_energy, mass, charge);
@@ -11831,563 +12421,1121 @@ export class WasmSmtProofObligation {
         }
     }
     /**
-     * Create a new proof obligation
-     *
-     * # Arguments
-     * * `name` - Obligation name (used in SMT-LIB2 comments)
-     * * `description` - Human-readable description
-     * * `kind` - One of: "precondition", "postcondition", "expected_value", "concentration"
-     * * `param1` - First parameter (probability for pre/post, expected value for EV, samples for concentration)
-     * * `param2` - Second parameter (unused for pre/post, epsilon for EV and concentration)
-     * @param {string} name
-     * @param {string} description
-     * @param {string} kind
-     * @param {number} param1
-     * @param {number} param2
+     * Create a new proof obligation
+     *
+     * # Arguments
+     * * `name` - Obligation name (used in SMT-LIB2 comments)
+     * * `description` - Human-readable description
+     * * `kind` - One of: "precondition", "postcondition", "expected_value", "concentration"
+     * * `param1` - First parameter (probability for pre/post, expected value for EV, samples for concentration)
+     * * `param2` - Second parameter (unused for pre/post, epsilon for EV and concentration)
+     * @param {string} name
+     * @param {string} description
+     * @param {string} kind
+     * @param {number} param1
+     * @param {number} param2
+     */
+    constructor(name, description, kind, param1, param2) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsmtproofobligation_new(ptr0, len0, ptr1, len1, ptr2, len2, param1, param2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmSmtProofObligationFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+const WasmSobolevSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsobolevspace_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Sobolev spaces H^k
+ *
+ * Provides function spaces with weak derivatives.
+ */
+export class WasmSobolevSpace {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSobolevSpace.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSobolevSpaceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSobolevSpaceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsobolevspace_free(ptr, 0);
+    }
+    /**
+     * Compute the H^1 seminorm |f|_{H^1} = ||f'||_{L^2}
+     * @param {Function} df
+     * @returns {number}
+     */
+    h1Seminorm(df) {
+        const ret = wasm.wasmsobolevspace_h1Seminorm(this.__wbg_ptr, df);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create H^1 over the unit interval [0, 1]
+     * @returns {WasmSobolevSpace}
+     */
+    static h1UnitInterval() {
+        const ret = wasm.wasmsobolevspace_h1UnitInterval();
+        return WasmSobolevSpace.__wrap(ret);
+    }
+    /**
+     * Create H^2 over the unit interval [0, 1]
+     * @returns {WasmSobolevSpace}
+     */
+    static h2UnitInterval() {
+        const ret = wasm.wasmsobolevspace_h2UnitInterval();
+        return WasmSobolevSpace.__wrap(ret);
+    }
+    /**
+     * Compute L^2 inner product <f, g>
+     * @param {Function} f
+     * @param {Function} g
+     * @returns {number}
+     */
+    l2InnerProduct(f, g) {
+        const ret = wasm.wasmsobolevspace_l2InnerProduct(this.__wbg_ptr, f, g);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute the Poincare constant estimate for the domain
+     *
+     * For [a,b], this is (b-a)/π
+     * @returns {number}
+     */
+    poincareConstant() {
+        const ret = wasm.wasmsobolevspace_poincareConstant(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Set the number of quadrature points
+     * @param {number} n
+     */
+    setQuadraturePoints(n) {
+        wasm.wasmsobolevspace_setQuadraturePoints(this.__wbg_ptr, n);
+    }
+    /**
+     * Create a Sobolev space H^k over an interval [a, b]
+     *
+     * # Arguments
+     * * `order` - The Sobolev regularity (1 for H^1, 2 for H^2)
+     * * `lower` - Lower bound of the interval
+     * * `upper` - Upper bound of the interval
+     * @param {number} order
+     * @param {number} lower
+     * @param {number} upper
+     */
+    constructor(order, lower, upper) {
+        const ret = wasm.wasmsobolevspace_new(order, lower, upper);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmSobolevSpaceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the domain bounds [lower, upper]
+     * @returns {Float64Array}
+     */
+    bounds() {
+        const ret = wasm.wasmsobolevspace_bounds(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Compute the H^k norm of a function using numerical integration
+     *
+     * # Arguments
+     * * `f` - JavaScript function f(x) to evaluate
+     * * `df` - JavaScript function f'(x) (first derivative)
+     * @param {Function} f
+     * @param {Function} df
+     * @returns {number}
+     */
+    h1Norm(f, df) {
+        const ret = wasm.wasmsobolevspace_h1Norm(this.__wbg_ptr, f, df);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute L^2 norm of a function
+     * @param {Function} f
+     * @returns {number}
+     */
+    l2Norm(f) {
+        const ret = wasm.wasmsobolevspace_l2Norm(this.__wbg_ptr, f);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Get the Sobolev order k
+     * @returns {number}
+     */
+    order() {
+        const ret = wasm.wasmsobolevspace_order(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
+const WasmSpacetimeVectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspacetimevector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for spacetime vectors
+ */
+export class WasmSpacetimeVector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSpacetimeVector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSpacetimeVectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSpacetimeVectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmspacetimevector_free(ptr, 0);
+    }
+    /**
+     * Check if vector is timelike (massive particle)
+     * @returns {boolean}
+     */
+    is_timelike() {
+        const ret = wasm.wasmspacetimevector_is_timelike(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if vector is spacelike
+     * @returns {boolean}
+     */
+    is_spacelike() {
+        const ret = wasm.wasmspacetimevector_is_spacelike(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Compute Minkowski norm squared
+     * @returns {number}
+     */
+    norm_squared() {
+        const ret = wasm.wasmspacetimevector_norm_squared(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute Minkowski inner product with another spacetime vector
+     * @param {WasmSpacetimeVector} other
+     * @returns {number}
+     */
+    minkowski_dot(other) {
+        _assertClass(other, WasmSpacetimeVector);
+        const ret = wasm.wasmspacetimevector_minkowski_dot(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get temporal component
+     * @returns {number}
+     */
+    get t() {
+        const ret = wasm.wasmfourvelocity_gamma(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get x component
+     * @returns {number}
+     */
+    get x() {
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get y component
+     * @returns {number}
+     */
+    get y() {
+        const ret = wasm.wasmevaluationresult_getGeometricDistance(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get z component
+     * @returns {number}
+     */
+    get z() {
+        const ret = wasm.wasmevaluationresult_getCombinedScore(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a new spacetime vector with components (ct, x, y, z)
+     * @param {number} t
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    constructor(t, x, y, z) {
+        const ret = wasm.wasmspacetimevector_new(t, x, y, z);
+        this.__wbg_ptr = ret >>> 0;
+        WasmSpacetimeVectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Check if vector is null (lightlike)
+     * @returns {boolean}
+     */
+    is_null() {
+        const ret = wasm.wasmspacetimevector_is_null(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Create a timelike vector
+     * @param {number} t
+     * @returns {WasmSpacetimeVector}
+     */
+    static timelike(t) {
+        const ret = wasm.wasmspacetimevector_timelike(t);
+        return WasmSpacetimeVector.__wrap(ret);
+    }
+    /**
+     * Create a spacelike vector
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {WasmSpacetimeVector}
+     */
+    static spacelike(x, y, z) {
+        const ret = wasm.wasmspacetimevector_spacelike(x, y, z);
+        return WasmSpacetimeVector.__wrap(ret);
+    }
+    /**
+     * Get string representation
+     * @returns {string}
+     */
+    to_string() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmspacetimevector_to_string(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const WasmSpectralDecompositionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspectraldecomposition_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for spectral decomposition
+ *
+ * Provides eigenvalue decomposition for symmetric matrices.
+ */
+export class WasmSpectralDecomposition {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSpectralDecomposition.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSpectralDecompositionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSpectralDecompositionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmspectraldecomposition_free(ptr, 0);
+    }
+    /**
+     * Get the eigenvalues
+     * @returns {Float64Array}
+     */
+    eigenvalues() {
+        const ret = wasm.wasmspectraldecomposition_eigenvalues(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Check if the decomposition is complete
+     * @returns {boolean}
+     */
+    isComplete() {
+        const ret = wasm.wasmspectraldecomposition_isComplete(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the eigenvectors as a flattened array
+     *
+     * Returns 4 eigenvectors of 4 components each (16 total)
+     * @returns {Float64Array}
+     */
+    eigenvectors() {
+        const ret = wasm.wasmspectraldecomposition_eigenvectors(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Apply f(T) = Σᵢ f(λᵢ) Pᵢ to a vector using functional calculus
+     *
+     * # Arguments
+     * * `f` - JavaScript function to apply to eigenvalues
+     * * `x` - Input vector
+     * @param {Function} f
+     * @param {Float64Array} x
+     * @returns {Float64Array}
+     */
+    applyFunction(f, x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmspectraldecomposition_applyFunction(this.__wbg_ptr, f, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Get the spectral radius (largest |eigenvalue|)
+     * @returns {number}
+     */
+    spectralRadius() {
+        const ret = wasm.wasmspectraldecomposition_spectralRadius(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the condition number
+     * @returns {number | undefined}
+     */
+    conditionNumber() {
+        const ret = wasm.wasmspectraldecomposition_conditionNumber(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Check if the operator is positive definite
+     * @returns {boolean}
+     */
+    isPositiveDefinite() {
+        const ret = wasm.wasmspectraldecomposition_isPositiveDefinite(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Check if the operator is positive semi-definite
+     * @returns {boolean}
+     */
+    isPositiveSemidefinite() {
+        const ret = wasm.wasmspectraldecomposition_isPositiveSemidefinite(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Apply the reconstructed operator T = Σᵢ λᵢ Pᵢ to a vector
+     * @param {Float64Array} x
+     * @returns {Float64Array}
+     */
+    apply(x) {
+        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmspectraldecomposition_apply(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Compute spectral decomposition of a symmetric matrix
+     *
+     * # Arguments
+     * * `matrix` - The symmetric matrix operator to decompose
+     * * `max_iterations` - Maximum iterations for eigenvalue computation
+     * * `tolerance` - Convergence tolerance
+     * @param {WasmMatrixOperator} matrix
+     * @param {number} max_iterations
+     * @param {number} tolerance
+     * @returns {WasmSpectralDecomposition}
+     */
+    static compute(matrix, max_iterations, tolerance) {
+        _assertClass(matrix, WasmMatrixOperator);
+        const ret = wasm.wasmspectraldecomposition_compute(matrix.__wbg_ptr, max_iterations, tolerance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmSpectralDecomposition.__wrap(ret[0]);
+    }
+}
+
+const WasmStabilityConditionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstabilitycondition_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Bridgeland-style stability conditions
+ */
+export class WasmStabilityCondition {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmStabilityConditionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmstabilitycondition_free(ptr, 0);
+    }
+    /**
+     * Count stable capabilities in a namespace
+     * @param {WasmNamespace} namespace
+     * @returns {number}
+     */
+    stableCount(namespace) {
+        _assertClass(namespace, WasmNamespace);
+        const ret = wasm.wasmstabilitycondition_stableCount(this.__wbg_ptr, namespace.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the trust level
+     * @returns {number}
+     */
+    getTrustLevel() {
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a stability condition on Gr(k, n) at a given trust level
+     * @param {number} k
+     * @param {number} n
+     * @param {number} trust_level
+     */
+    constructor(k, n, trust_level) {
+        const ret = wasm.wasmstabilitycondition_new(k, n, trust_level);
+        this.__wbg_ptr = ret >>> 0;
+        WasmStabilityConditionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Compute the phase of a Schubert class under this stability condition
+     * @param {WasmSchubertClass} _class
+     * @returns {number}
      */
-    constructor(name, description, kind, param1, param2) {
-        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmsmtproofobligation_new(ptr0, len0, ptr1, len1, ptr2, len2, param1, param2);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        WasmSmtProofObligationFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    phase(_class) {
+        _assertClass(_class, WasmSchubertClass);
+        const ret = wasm.wasmstabilitycondition_phase(this.__wbg_ptr, _class.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Check if a capability is stable under this condition
+     * @param {WasmCapability} capability
+     * @returns {boolean}
+     */
+    isStable(capability) {
+        _assertClass(capability, WasmCapability);
+        const ret = wasm.wasmstabilitycondition_isStable(this.__wbg_ptr, capability.__wbg_ptr);
+        return ret !== 0;
     }
 }
 
-const WasmSobolevSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmStaticMultiDual2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsobolevspace_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for Sobolev spaces H^k
- *
- * Provides function spaces with weak derivatives.
- */
-export class WasmSobolevSpace {
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstaticmultidual2_free(ptr >>> 0, 1));
+
+export class WasmStaticMultiDual2 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmSobolevSpace.prototype);
+        const obj = Object.create(WasmStaticMultiDual2.prototype);
         obj.__wbg_ptr = ptr;
-        WasmSobolevSpaceFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmStaticMultiDual2Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmSobolevSpaceFinalization.unregister(this);
+        WasmStaticMultiDual2Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmsobolevspace_free(ptr, 0);
+        wasm.__wbg_wasmstaticmultidual2_free(ptr, 0);
     }
     /**
-     * Compute the H^1 seminorm |f|_{H^1} = ||f'||_{L^2}
-     * @param {Function} df
-     * @returns {number}
+     * Get the fixed-size gradient as a JavaScript array-compatible vector.
+     * @returns {Float64Array}
      */
-    h1Seminorm(df) {
-        const ret = wasm.wasmsobolevspace_h1Seminorm(this.__wbg_ptr, df);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
+    getGradient() {
+        const ret = wasm.wasmstaticmultidual2_getGradient(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * Create H^1 over the unit interval [0, 1]
-     * @returns {WasmSobolevSpace}
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual2} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual2}
      */
-    static h1UnitInterval() {
-        const ret = wasm.wasmsobolevspace_h1UnitInterval();
-        return WasmSobolevSpace.__wrap(ret);
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Create H^2 over the unit interval [0, 1]
-     * @returns {WasmSobolevSpace}
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual2} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual2}
      */
-    static h2UnitInterval() {
-        const ret = wasm.wasmsobolevspace_h2UnitInterval();
-        return WasmSobolevSpace.__wrap(ret);
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Compute L^2 inner product <f, g>
-     * @param {Function} f
-     * @param {Function} g
-     * @returns {number}
+     * Convert to the heap-backed multi-dual wrapper.
+     * @returns {WasmMultiDualNumber}
      */
-    l2InnerProduct(f, g) {
-        const ret = wasm.wasmsobolevspace_l2InnerProduct(this.__wbg_ptr, f, g);
+    toMultiDual() {
+        const ret = wasm.wasmstaticmultidual2_toMultiDual(this.__wbg_ptr);
+        return WasmMultiDualNumber.__wrap(ret);
+    }
+    /**
+     * Addition.
+     * @param {WasmStaticMultiDual2} other
+     * @returns {WasmStaticMultiDual2}
+     */
+    add(other) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual2.__wrap(ret);
+    }
+    /**
+     * Division.
+     * @param {WasmStaticMultiDual2} other
+     * @returns {WasmStaticMultiDual2}
+     */
+    div(other) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_div(this.__wbg_ptr, other.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0];
+        return WasmStaticMultiDual2.__wrap(ret[0]);
     }
     /**
-     * Compute the Poincare constant estimate for the domain
-     *
-     * For [a,b], this is (b-a)/π
-     * @returns {number}
+     * Multiplication.
+     * @param {WasmStaticMultiDual2} other
+     * @returns {WasmStaticMultiDual2}
      */
-    poincareConstant() {
-        const ret = wasm.wasmsobolevspace_poincareConstant(this.__wbg_ptr);
-        return ret;
+    mul(other) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_mul(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Set the number of quadrature points
-     * @param {number} n
+     * Negation.
+     * @returns {WasmStaticMultiDual2}
      */
-    setQuadraturePoints(n) {
-        wasm.wasmsobolevspace_setQuadraturePoints(this.__wbg_ptr, n);
+    neg() {
+        const ret = wasm.wasmstaticmultidual2_neg(this.__wbg_ptr);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Create a Sobolev space H^k over an interval [a, b]
-     *
-     * # Arguments
-     * * `order` - The Sobolev regularity (1 for H^1, 2 for H^2)
-     * * `lower` - Lower bound of the interval
-     * * `upper` - Upper bound of the interval
-     * @param {number} order
-     * @param {number} lower
-     * @param {number} upper
+     * Create a fixed-size multi-dual number from a value and gradient.
+     * @param {number} value
+     * @param {Float64Array} gradient
      */
-    constructor(order, lower, upper) {
-        const ret = wasm.wasmsobolevspace_new(order, lower, upper);
+    constructor(value, gradient) {
+        const ptr0 = passArrayF64ToWasm0(gradient, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual2_new(value, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        WasmSobolevSpaceFinalization.register(this, this.__wbg_ptr, this);
+        WasmStaticMultiDual2Finalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Get the domain bounds [lower, upper]
-     * @returns {Float64Array}
+     * Subtraction.
+     * @param {WasmStaticMultiDual2} other
+     * @returns {WasmStaticMultiDual2}
      */
-    bounds() {
-        const ret = wasm.wasmsobolevspace_bounds(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    sub(other) {
+        _assertClass(other, WasmStaticMultiDual2);
+        const ret = wasm.wasmstaticmultidual2_sub(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual2.__wrap(ret);
     }
     /**
-     * Compute the H^k norm of a function using numerical integration
-     *
-     * # Arguments
-     * * `f` - JavaScript function f(x) to evaluate
-     * * `df` - JavaScript function f'(x) (first derivative)
-     * @param {Function} f
-     * @param {Function} df
+     * Number of derivative variables.
      * @returns {number}
      */
-    h1Norm(f, df) {
-        const ret = wasm.wasmsobolevspace_h1Norm(this.__wbg_ptr, f, df);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
+    nVars() {
+        const ret = wasm.wasmstaticmultidual2_nVars(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Compute L^2 norm of a function
-     * @param {Function} f
-     * @returns {number}
+     * Create a constant with zero gradient.
+     * @param {number} value
+     * @returns {WasmStaticMultiDual2}
      */
-    l2Norm(f) {
-        const ret = wasm.wasmsobolevspace_l2Norm(this.__wbg_ptr, f);
+    static constant(value) {
+        const ret = wasm.wasmstaticmultidual2_constant(value);
+        return WasmStaticMultiDual2.__wrap(ret);
+    }
+    /**
+     * Create a basis-seeded variable.
+     * @param {number} value
+     * @param {number} var_index
+     * @returns {WasmStaticMultiDual2}
+     */
+    static variable(value, var_index) {
+        const ret = wasm.wasmstaticmultidual2_variable(value, var_index);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0];
+        return WasmStaticMultiDual2.__wrap(ret[0]);
     }
     /**
-     * Get the Sobolev order k
+     * Get the function value.
      * @returns {number}
      */
-    order() {
-        const ret = wasm.wasmsobolevspace_order(this.__wbg_ptr);
-        return ret >>> 0;
+    getValue() {
+        const ret = wasm.wasmevaluationresult_getGeometricDistance(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create one fixed-size variable per coordinate.
+     * @param {Float64Array} values
+     * @returns {Array<any>}
+     */
+    static variables(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual2_variables(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
 }
 
-const WasmSpacetimeVectorFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmStaticMultiDual3Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspacetimevector_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for spacetime vectors
- */
-export class WasmSpacetimeVector {
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstaticmultidual3_free(ptr >>> 0, 1));
+
+export class WasmStaticMultiDual3 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmSpacetimeVector.prototype);
+        const obj = Object.create(WasmStaticMultiDual3.prototype);
         obj.__wbg_ptr = ptr;
-        WasmSpacetimeVectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmStaticMultiDual3Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmSpacetimeVectorFinalization.unregister(this);
+        WasmStaticMultiDual3Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmspacetimevector_free(ptr, 0);
+        wasm.__wbg_wasmstaticmultidual3_free(ptr, 0);
     }
     /**
-     * Check if vector is timelike (massive particle)
-     * @returns {boolean}
+     * Get the fixed-size gradient as a JavaScript array-compatible vector.
+     * @returns {Float64Array}
      */
-    is_timelike() {
-        const ret = wasm.wasmspacetimevector_is_timelike(this.__wbg_ptr);
-        return ret !== 0;
+    getGradient() {
+        const ret = wasm.wasmstaticmultidual3_getGradient(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * Check if vector is spacelike
-     * @returns {boolean}
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual3} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual3}
      */
-    is_spacelike() {
-        const ret = wasm.wasmspacetimevector_is_spacelike(this.__wbg_ptr);
-        return ret !== 0;
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Compute Minkowski norm squared
-     * @returns {number}
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual3} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual3}
      */
-    norm_squared() {
-        const ret = wasm.wasmspacetimevector_norm_squared(this.__wbg_ptr);
-        return ret;
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Compute Minkowski inner product with another spacetime vector
-     * @param {WasmSpacetimeVector} other
-     * @returns {number}
+     * Convert to the heap-backed multi-dual wrapper.
+     * @returns {WasmMultiDualNumber}
      */
-    minkowski_dot(other) {
-        _assertClass(other, WasmSpacetimeVector);
-        const ret = wasm.wasmspacetimevector_minkowski_dot(this.__wbg_ptr, other.__wbg_ptr);
-        return ret;
+    toMultiDual() {
+        const ret = wasm.wasmstaticmultidual3_toMultiDual(this.__wbg_ptr);
+        return WasmMultiDualNumber.__wrap(ret);
     }
     /**
-     * Get temporal component
-     * @returns {number}
+     * Addition.
+     * @param {WasmStaticMultiDual3} other
+     * @returns {WasmStaticMultiDual3}
      */
-    get t() {
-        const ret = wasm.wasmfourvelocity_gamma(this.__wbg_ptr);
-        return ret;
+    add(other) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Get x component
-     * @returns {number}
+     * Division.
+     * @param {WasmStaticMultiDual3} other
+     * @returns {WasmStaticMultiDual3}
      */
-    get x() {
-        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
-        return ret;
+    div(other) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_div(this.__wbg_ptr, other.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmStaticMultiDual3.__wrap(ret[0]);
     }
     /**
-     * Get y component
-     * @returns {number}
+     * Multiplication.
+     * @param {WasmStaticMultiDual3} other
+     * @returns {WasmStaticMultiDual3}
      */
-    get y() {
-        const ret = wasm.wasmevaluationresult_getGeometricDistance(this.__wbg_ptr);
-        return ret;
+    mul(other) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_mul(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Get z component
-     * @returns {number}
+     * Negation.
+     * @returns {WasmStaticMultiDual3}
+     */
+    neg() {
+        const ret = wasm.wasmstaticmultidual3_neg(this.__wbg_ptr);
+        return WasmStaticMultiDual3.__wrap(ret);
+    }
+    /**
+     * Create a fixed-size multi-dual number from a value and gradient.
+     * @param {number} value
+     * @param {Float64Array} gradient
+     */
+    constructor(value, gradient) {
+        const ptr0 = passArrayF64ToWasm0(gradient, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual3_new(value, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmStaticMultiDual3Finalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Subtraction.
+     * @param {WasmStaticMultiDual3} other
+     * @returns {WasmStaticMultiDual3}
      */
-    get z() {
-        const ret = wasm.wasmevaluationresult_getCombinedScore(this.__wbg_ptr);
-        return ret;
+    sub(other) {
+        _assertClass(other, WasmStaticMultiDual3);
+        const ret = wasm.wasmstaticmultidual3_sub(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Create a new spacetime vector with components (ct, x, y, z)
-     * @param {number} t
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
+     * Number of derivative variables.
+     * @returns {number}
      */
-    constructor(t, x, y, z) {
-        const ret = wasm.wasmspacetimevector_new(t, x, y, z);
-        this.__wbg_ptr = ret >>> 0;
-        WasmSpacetimeVectorFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    nVars() {
+        const ret = wasm.wasmstaticmultidual3_nVars(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Check if vector is null (lightlike)
-     * @returns {boolean}
+     * Create a constant with zero gradient.
+     * @param {number} value
+     * @returns {WasmStaticMultiDual3}
      */
-    is_null() {
-        const ret = wasm.wasmspacetimevector_is_null(this.__wbg_ptr);
-        return ret !== 0;
+    static constant(value) {
+        const ret = wasm.wasmstaticmultidual3_constant(value);
+        return WasmStaticMultiDual3.__wrap(ret);
     }
     /**
-     * Create a timelike vector
-     * @param {number} t
-     * @returns {WasmSpacetimeVector}
+     * Create a basis-seeded variable.
+     * @param {number} value
+     * @param {number} var_index
+     * @returns {WasmStaticMultiDual3}
      */
-    static timelike(t) {
-        const ret = wasm.wasmspacetimevector_timelike(t);
-        return WasmSpacetimeVector.__wrap(ret);
+    static variable(value, var_index) {
+        const ret = wasm.wasmstaticmultidual3_variable(value, var_index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmStaticMultiDual3.__wrap(ret[0]);
     }
     /**
-     * Create a spacelike vector
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @returns {WasmSpacetimeVector}
+     * Get the function value.
+     * @returns {number}
      */
-    static spacelike(x, y, z) {
-        const ret = wasm.wasmspacetimevector_spacelike(x, y, z);
-        return WasmSpacetimeVector.__wrap(ret);
+    getValue() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Get string representation
-     * @returns {string}
+     * Create one fixed-size variable per coordinate.
+     * @param {Float64Array} values
+     * @returns {Array<any>}
      */
-    to_string() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.wasmspacetimevector_to_string(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    static variables(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual3_variables(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return takeFromExternrefTable0(ret[0]);
     }
 }
 
-const WasmSpectralDecompositionFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmStaticMultiDual4Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmspectraldecomposition_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for spectral decomposition
- *
- * Provides eigenvalue decomposition for symmetric matrices.
- */
-export class WasmSpectralDecomposition {
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstaticmultidual4_free(ptr >>> 0, 1));
+
+export class WasmStaticMultiDual4 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmSpectralDecomposition.prototype);
+        const obj = Object.create(WasmStaticMultiDual4.prototype);
         obj.__wbg_ptr = ptr;
-        WasmSpectralDecompositionFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmStaticMultiDual4Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmSpectralDecompositionFinalization.unregister(this);
+        WasmStaticMultiDual4Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmspectraldecomposition_free(ptr, 0);
+        wasm.__wbg_wasmstaticmultidual4_free(ptr, 0);
     }
     /**
-     * Get the eigenvalues
+     * Get the fixed-size gradient as a JavaScript array-compatible vector.
      * @returns {Float64Array}
      */
-    eigenvalues() {
-        const ret = wasm.wasmspectraldecomposition_eigenvalues(this.__wbg_ptr);
+    getGradient() {
+        const ret = wasm.wasmstaticmultidual4_getGradient(this.__wbg_ptr);
         var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
     /**
-     * Check if the decomposition is complete
-     * @returns {boolean}
+     * Maximum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual4} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual4}
      */
-    isComplete() {
-        const ret = wasm.wasmspectraldecomposition_isComplete(this.__wbg_ptr);
-        return ret !== 0;
+    maxByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_maxByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Get the eigenvectors as a flattened array
-     *
-     * Returns 4 eigenvectors of 4 components each (16 total)
-     * @returns {Float64Array}
+     * Minimum with explicit derivative tie handling.
+     * @param {WasmStaticMultiDual4} other
+     * @param {WasmBranchPolicy} policy
+     * @returns {WasmStaticMultiDual4}
      */
-    eigenvectors() {
-        const ret = wasm.wasmspectraldecomposition_eigenvectors(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
+    minByPolicy(other, policy) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_minByPolicy(this.__wbg_ptr, other.__wbg_ptr, policy);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Apply f(T) = Σᵢ f(λᵢ) Pᵢ to a vector using functional calculus
-     *
-     * # Arguments
-     * * `f` - JavaScript function to apply to eigenvalues
-     * * `x` - Input vector
-     * @param {Function} f
-     * @param {Float64Array} x
-     * @returns {Float64Array}
+     * Convert to the heap-backed multi-dual wrapper.
+     * @returns {WasmMultiDualNumber}
      */
-    applyFunction(f, x) {
-        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmspectraldecomposition_applyFunction(this.__wbg_ptr, f, ptr0, len0);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v2;
+    toMultiDual() {
+        const ret = wasm.wasmstaticmultidual4_toMultiDual(this.__wbg_ptr);
+        return WasmMultiDualNumber.__wrap(ret);
     }
     /**
-     * Get the spectral radius (largest |eigenvalue|)
-     * @returns {number}
+     * Addition.
+     * @param {WasmStaticMultiDual4} other
+     * @returns {WasmStaticMultiDual4}
      */
-    spectralRadius() {
-        const ret = wasm.wasmspectraldecomposition_spectralRadius(this.__wbg_ptr);
-        return ret;
+    add(other) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Get the condition number
-     * @returns {number | undefined}
+     * Division.
+     * @param {WasmStaticMultiDual4} other
+     * @returns {WasmStaticMultiDual4}
      */
-    conditionNumber() {
-        const ret = wasm.wasmspectraldecomposition_conditionNumber(this.__wbg_ptr);
-        return ret[0] === 0 ? undefined : ret[1];
+    div(other) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_div(this.__wbg_ptr, other.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmStaticMultiDual4.__wrap(ret[0]);
     }
     /**
-     * Check if the operator is positive definite
-     * @returns {boolean}
+     * Multiplication.
+     * @param {WasmStaticMultiDual4} other
+     * @returns {WasmStaticMultiDual4}
      */
-    isPositiveDefinite() {
-        const ret = wasm.wasmspectraldecomposition_isPositiveDefinite(this.__wbg_ptr);
-        return ret !== 0;
+    mul(other) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_mul(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Check if the operator is positive semi-definite
-     * @returns {boolean}
+     * Negation.
+     * @returns {WasmStaticMultiDual4}
      */
-    isPositiveSemidefinite() {
-        const ret = wasm.wasmspectraldecomposition_isPositiveSemidefinite(this.__wbg_ptr);
-        return ret !== 0;
+    neg() {
+        const ret = wasm.wasmstaticmultidual4_neg(this.__wbg_ptr);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Apply the reconstructed operator T = Σᵢ λᵢ Pᵢ to a vector
-     * @param {Float64Array} x
-     * @returns {Float64Array}
+     * Create a fixed-size multi-dual number from a value and gradient.
+     * @param {number} value
+     * @param {Float64Array} gradient
      */
-    apply(x) {
-        const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    constructor(value, gradient) {
+        const ptr0 = passArrayF64ToWasm0(gradient, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmspectraldecomposition_apply(this.__wbg_ptr, ptr0, len0);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v2;
-    }
-    /**
-     * Compute spectral decomposition of a symmetric matrix
-     *
-     * # Arguments
-     * * `matrix` - The symmetric matrix operator to decompose
-     * * `max_iterations` - Maximum iterations for eigenvalue computation
-     * * `tolerance` - Convergence tolerance
-     * @param {WasmMatrixOperator} matrix
-     * @param {number} max_iterations
-     * @param {number} tolerance
-     * @returns {WasmSpectralDecomposition}
-     */
-    static compute(matrix, max_iterations, tolerance) {
-        _assertClass(matrix, WasmMatrixOperator);
-        const ret = wasm.wasmspectraldecomposition_compute(matrix.__wbg_ptr, max_iterations, tolerance);
+        const ret = wasm.wasmstaticmultidual4_new(value, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return WasmSpectralDecomposition.__wrap(ret[0]);
-    }
-}
-
-const WasmStabilityConditionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstabilitycondition_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for Bridgeland-style stability conditions
- */
-export class WasmStabilityCondition {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmStabilityConditionFinalization.unregister(this);
-        return ptr;
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmStaticMultiDual4Finalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmstabilitycondition_free(ptr, 0);
+    /**
+     * Subtraction.
+     * @param {WasmStaticMultiDual4} other
+     * @returns {WasmStaticMultiDual4}
+     */
+    sub(other) {
+        _assertClass(other, WasmStaticMultiDual4);
+        const ret = wasm.wasmstaticmultidual4_sub(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Count stable capabilities in a namespace
-     * @param {WasmNamespace} namespace
+     * Number of derivative variables.
      * @returns {number}
      */
-    stableCount(namespace) {
-        _assertClass(namespace, WasmNamespace);
-        const ret = wasm.wasmstabilitycondition_stableCount(this.__wbg_ptr, namespace.__wbg_ptr);
+    nVars() {
+        const ret = wasm.wasmhilbertspace_dimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Get the trust level
-     * @returns {number}
+     * Create a constant with zero gradient.
+     * @param {number} value
+     * @returns {WasmStaticMultiDual4}
      */
-    getTrustLevel() {
-        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
-        return ret;
+    static constant(value) {
+        const ret = wasm.wasmstaticmultidual4_constant(value);
+        return WasmStaticMultiDual4.__wrap(ret);
     }
     /**
-     * Create a stability condition on Gr(k, n) at a given trust level
-     * @param {number} k
-     * @param {number} n
-     * @param {number} trust_level
+     * Create a basis-seeded variable.
+     * @param {number} value
+     * @param {number} var_index
+     * @returns {WasmStaticMultiDual4}
      */
-    constructor(k, n, trust_level) {
-        const ret = wasm.wasmstabilitycondition_new(k, n, trust_level);
-        this.__wbg_ptr = ret >>> 0;
-        WasmStabilityConditionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    static variable(value, var_index) {
+        const ret = wasm.wasmstaticmultidual4_variable(value, var_index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmStaticMultiDual4.__wrap(ret[0]);
     }
     /**
-     * Compute the phase of a Schubert class under this stability condition
-     * @param {WasmSchubertClass} _class
+     * Get the function value.
      * @returns {number}
      */
-    phase(_class) {
-        _assertClass(_class, WasmSchubertClass);
-        const ret = wasm.wasmstabilitycondition_phase(this.__wbg_ptr, _class.__wbg_ptr);
+    getValue() {
+        const ret = wasm.wasmschwarzschildmetric_schwarzschild_radius(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Check if a capability is stable under this condition
-     * @param {WasmCapability} capability
-     * @returns {boolean}
+     * Create one fixed-size variable per coordinate.
+     * @param {Float64Array} values
+     * @returns {Array<any>}
      */
-    isStable(capability) {
-        _assertClass(capability, WasmCapability);
-        const ret = wasm.wasmstabilitycondition_isStable(this.__wbg_ptr, capability.__wbg_ptr);
-        return ret !== 0;
+    static variables(values) {
+        const ptr0 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstaticmultidual4_variables(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
 }
 
@@ -14175,7 +15323,7 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_7c839ead6adae856 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_845eb41485557ffc = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
@@ -14200,7 +15348,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_965(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_1057(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -14291,6 +15439,10 @@ function __wbg_get_imports() {
         const ret = WasmIntersectionResult.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_wasmmultidualnumber_new = function(arg0) {
+        const ret = WasmMultiDualNumber.__wrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_wasmnamespace_unwrap = function(arg0) {
         const ret = WasmNamespace.__unwrap(arg0);
         return ret;
@@ -14319,6 +15471,18 @@ function __wbg_get_imports() {
         const ret = WasmSpacetimeVector.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_wasmstaticmultidual2_new = function(arg0) {
+        const ret = WasmStaticMultiDual2.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasmstaticmultidual3_new = function(arg0) {
+        const ret = WasmStaticMultiDual3.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_wasmstaticmultidual4_new = function(arg0) {
+        const ret = WasmStaticMultiDual4.__wrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_wasmtropicalnumber_new = function(arg0) {
         const ret = WasmTropicalNumber.__wrap(arg0);
         return ret;
@@ -14336,8 +15500,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper2686 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 70, __wbg_adapter_30);
+    imports.wbg.__wbindgen_closure_wrapper2835 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 71, __wbg_adapter_30);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {