universal-physics-tensor 0.4.5

package/dist/bridges/equations/be-30-flm-first-law.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Bridge Equation 30 — FLM first law of entanglement entropy
+ * (Faulkner-Lewkowycz-Maldacena 2013, Wave Y AST-encoding).
+ *
+ *   δS_EE(R) = δ⟨H_R⟩
+ *
+ * The first-law-of-entanglement-entropy linear-response identity:
+ * for a small perturbation of the global state, the variation of the
+ * entanglement entropy on a region R equals the variation of the
+ * expectation value of the modular Hamiltonian H_R for that region.
+ * This is the canonical CFT-bulk-loop input for Faulkner-Lewkowycz-
+ * Maldacena's bulk one-loop correction to Ryu-Takayanagi.
+ *
+ * References:
+ *   - Faulkner, Lewkowycz & Maldacena 2013 *JHEP* 11:074
+ *     (arXiv:1307.2892; canonical FLM bulk-entanglement-entropy
+ *     correction; uses δS_EE = ⟨δH_R⟩ as input).
+ *   - Blanco, Casini, Hung, Myers 2013 *JHEP* 08:060
+ *     (arXiv:1305.3182; canonical statement of the first law of
+ *     entanglement entropy).
+ *
+ * Status: speculative.
+ *
+ * Honest-claude scope notes:
+ *   - Both sides are dimensionless (in nats; or k_B-rescaled to entropy
+ *     units of [J/K]). The encoding pins the dimensionless convention
+ *     (S_EE in nats; modular Hamiltonian expectation in nats).
+ *   - The equation is a TAUTOLOGY in the sense that δS_EE / δ⟨H_R⟩ = 1
+ *     by construction. The encoding nonetheless pins the dimensional
+ *     structure (both sides DIMENSIONLESS) and the scalar relation; the
+ *     bracket-check tests verify only the trivial linear-response
+ *     identity, not a non-trivial physical prediction.
+ *   - As a non-trivial secondary cross-check, the Bekenstein universal
+ *     entropy bound `S_EE ≤ 2π R E / (ℏc)` is exposed via a separate
+ *     evaluator `evaluateBekensteinBound` for sanity-checking
+ *     entanglement-entropy magnitudes.
+ *   - The full operator structure of H_R is the bridge framing; the
+ *     scalar first-law identity is the AST-encodable content.
+ *
+ * @see docs/specification/Part-II.md ("Bridge Equation 30")
+ * @see src/bridges/index.ts BRIDGE_EQUATIONS.find(e => e.id === 30)
+ * @module bridges/equations/be-30-flm-first-law
+ */
+import type { ExprNode, DimensionValidationReport } from '../../dimensional/validator.js';
+/**
+ * RHS of the FLM first-law identity:
+ *   δS_EE = δ⟨H_R⟩
+ *
+ * Both sides are dimensionless (S_EE in nats; modular-Hamiltonian
+ * expectation rescaled to nats).
+ */
+export declare const BE30_FLM_RHS: ExprNode;
+/** LHS: δS_EE has dimension [1] (nats). */
+export declare const BE30_FLM_LHS: ExprNode;
+export interface FLMFirstLawInputs {
+    /**
+     * Variation of the modular-Hamiltonian expectation value δ⟨H_R⟩, in
+     * nats (dimensionless). Must be finite.
+     */
+    delta_avg_H_R: number;
+}
+/**
+ * Evaluate the FLM first-law identity δS_EE = δ⟨H_R⟩ — a tautology by
+ * construction.
+ *
+ * @returns Variation of entanglement entropy in nats.
+ */
+export declare function evaluateFLMFirstLaw(input: FLMFirstLawInputs): number;
+export interface BekensteinBoundInputs {
+    /** Region radius R (m). Must be > 0 and finite. */
+    R_m: number;
+    /** Total energy E in the region (J). Must be > 0 and finite. */
+    E_J: number;
+}
+/**
+ * Evaluate the Bekenstein universal entropy bound
+ *
+ *   S_EE ≤ 2π R E / (ℏ c)
+ *
+ * (Bekenstein 1981 *Phys. Rev. D* 23:287). Returns the *upper bound*
+ * on S_EE in nats. Used as a sanity-check on the FLM linear-response
+ * identity (which is a tautology by itself; the bound provides a
+ * non-trivial physical magnitude check).
+ *
+ * @returns Bekenstein upper bound on entropy in nats.
+ */
+export declare function evaluateBekensteinBound(input: BekensteinBoundInputs): number;
+/**
+ * Run the AST through the dimensional analyzer; both sides should be
+ * DIMENSIONLESS.
+ */
+export declare function validateBE30Dimensions(): DimensionValidationReport;
+//# sourceMappingURL=be-30-flm-first-law.d.ts.map

package/dist/bridges/equations/be-30-flm-first-law.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"be-30-flm-first-law.d.ts","sourceRoot":"","sources":["../../../src/bridges/equations/be-30-flm-first-law.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAU1F;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,QAA8C,CAAC;AAE1E,2CAA2C;AAC3C,eAAO,MAAM,YAAY,EAAE,QAA2C,CAAC;AAIvE,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAQpE;AAID,MAAM,WAAW,qBAAqB;IACpC,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAc5E;AAID;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,yBAAyB,CASlE"}

package/dist/bridges/equations/be-30-flm-first-law.js

@@ -0,0 +1,109 @@
+/**
+ * Bridge Equation 30 — FLM first law of entanglement entropy
+ * (Faulkner-Lewkowycz-Maldacena 2013, Wave Y AST-encoding).
+ *
+ *   δS_EE(R) = δ⟨H_R⟩
+ *
+ * The first-law-of-entanglement-entropy linear-response identity:
+ * for a small perturbation of the global state, the variation of the
+ * entanglement entropy on a region R equals the variation of the
+ * expectation value of the modular Hamiltonian H_R for that region.
+ * This is the canonical CFT-bulk-loop input for Faulkner-Lewkowycz-
+ * Maldacena's bulk one-loop correction to Ryu-Takayanagi.
+ *
+ * References:
+ *   - Faulkner, Lewkowycz & Maldacena 2013 *JHEP* 11:074
+ *     (arXiv:1307.2892; canonical FLM bulk-entanglement-entropy
+ *     correction; uses δS_EE = ⟨δH_R⟩ as input).
+ *   - Blanco, Casini, Hung, Myers 2013 *JHEP* 08:060
+ *     (arXiv:1305.3182; canonical statement of the first law of
+ *     entanglement entropy).
+ *
+ * Status: speculative.
+ *
+ * Honest-claude scope notes:
+ *   - Both sides are dimensionless (in nats; or k_B-rescaled to entropy
+ *     units of [J/K]). The encoding pins the dimensionless convention
+ *     (S_EE in nats; modular Hamiltonian expectation in nats).
+ *   - The equation is a TAUTOLOGY in the sense that δS_EE / δ⟨H_R⟩ = 1
+ *     by construction. The encoding nonetheless pins the dimensional
+ *     structure (both sides DIMENSIONLESS) and the scalar relation; the
+ *     bracket-check tests verify only the trivial linear-response
+ *     identity, not a non-trivial physical prediction.
+ *   - As a non-trivial secondary cross-check, the Bekenstein universal
+ *     entropy bound `S_EE ≤ 2π R E / (ℏc)` is exposed via a separate
+ *     evaluator `evaluateBekensteinBound` for sanity-checking
+ *     entanglement-entropy magnitudes.
+ *   - The full operator structure of H_R is the bridge framing; the
+ *     scalar first-law identity is the AST-encodable content.
+ *
+ * @see docs/specification/Part-II.md ("Bridge Equation 30")
+ * @see src/bridges/index.ts BRIDGE_EQUATIONS.find(e => e.id === 30)
+ * @module bridges/equations/be-30-flm-first-law
+ */
+import { validate, validateEquation } from '../../dimensional/validator.js';
+import { DIMENSIONLESS, } from '../../dimensional/types.js';
+import { PhysicalConstants } from '../../core/types.js';
+const sym = (name, dim) => ({ kind: 'symbol', name, dim });
+/**
+ * RHS of the FLM first-law identity:
+ *   δS_EE = δ⟨H_R⟩
+ *
+ * Both sides are dimensionless (S_EE in nats; modular-Hamiltonian
+ * expectation rescaled to nats).
+ */
+export const BE30_FLM_RHS = sym('delta_avg_H_R', DIMENSIONLESS);
+/** LHS: δS_EE has dimension [1] (nats). */
+export const BE30_FLM_LHS = sym('delta_S_EE', DIMENSIONLESS);
+/**
+ * Evaluate the FLM first-law identity δS_EE = δ⟨H_R⟩ — a tautology by
+ * construction.
+ *
+ * @returns Variation of entanglement entropy in nats.
+ */
+export function evaluateFLMFirstLaw(input) {
+    const { delta_avg_H_R } = input;
+    if (!Number.isFinite(delta_avg_H_R)) {
+        throw new RangeError(`evaluateFLMFirstLaw: delta_avg_H_R must be finite, got ${delta_avg_H_R}`);
+    }
+    return delta_avg_H_R;
+}
+/**
+ * Evaluate the Bekenstein universal entropy bound
+ *
+ *   S_EE ≤ 2π R E / (ℏ c)
+ *
+ * (Bekenstein 1981 *Phys. Rev. D* 23:287). Returns the *upper bound*
+ * on S_EE in nats. Used as a sanity-check on the FLM linear-response
+ * identity (which is a tautology by itself; the bound provides a
+ * non-trivial physical magnitude check).
+ *
+ * @returns Bekenstein upper bound on entropy in nats.
+ */
+export function evaluateBekensteinBound(input) {
+    const { R_m, E_J } = input;
+    if (!Number.isFinite(R_m) || R_m <= 0) {
+        throw new RangeError(`evaluateBekensteinBound: R_m must be a finite positive number, got ${R_m}`);
+    }
+    if (!Number.isFinite(E_J) || E_J <= 0) {
+        throw new RangeError(`evaluateBekensteinBound: E_J must be a finite positive number, got ${E_J}`);
+    }
+    const { hbar, c } = PhysicalConstants;
+    return (2 * Math.PI * R_m * E_J) / (hbar * c);
+}
+// --- Self-validation ---
+/**
+ * Run the AST through the dimensional analyzer; both sides should be
+ * DIMENSIONLESS.
+ */
+export function validateBE30Dimensions() {
+    const eq = validateEquation(BE30_FLM_LHS, BE30_FLM_RHS);
+    const lhs = validate(BE30_FLM_LHS);
+    const rhs = validate(BE30_FLM_RHS);
+    return {
+        ok: eq.ok,
+        lhsDim: lhs.inferredDimension,
+        rhsDim: rhs.inferredDimension,
+    };
+}
+//# sourceMappingURL=be-30-flm-first-law.js.map

package/dist/bridges/equations/be-30-flm-first-law.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"be-30-flm-first-law.js","sourceRoot":"","sources":["../../../src/bridges/equations/be-30-flm-first-law.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAEL,aAAa,GACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,GAAG,GAAG,CAAC,IAAY,EAAE,GAAc,EAAY,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;AAExF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAa,GAAG,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;AAE1E,2CAA2C;AAC3C,MAAM,CAAC,MAAM,YAAY,GAAa,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;AAYvE;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAwB;IAC1D,MAAM,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC;IAChC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,UAAU,CAClB,0DAA0D,aAAa,EAAE,CAC1E,CAAC;IACJ,CAAC;IACD,OAAO,aAAa,CAAC;AACvB,CAAC;AAWD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAA4B;IAClE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;IAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,UAAU,CAClB,sEAAsE,GAAG,EAAE,CAC5E,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,UAAU,CAClB,sEAAsE,GAAG,EAAE,CAC5E,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,iBAAiB,CAAC;IACtC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;AAChD,CAAC;AAED,0BAA0B;AAE1B;;;GAGG;AACH,MAAM,UAAU,sBAAsB;IACpC,MAAM,EAAE,GAAG,gBAAgB,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IACxD,MAAM,GAAG,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;IACnC,MAAM,GAAG,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;IACnC,OAAO;QACL,EAAE,EAAE,EAAE,CAAC,EAAE;QACT,MAAM,EAAE,GAAG,CAAC,iBAAiB;QAC7B,MAAM,EAAE,GAAG,CAAC,iBAAiB;KAC9B,CAAC;AACJ,CAAC"}

package/dist/bridges/equations/be-31-causal-set-bd.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Bridge Equation 31 — Causal Set Continuum Limit (Benincasa-Dowker
+ * d=4 discrete Ricci scalar, post Wave I.B C3 reformulation).
+ *
+ *   R(p) = (4/√6) · ℓ_P^(-2) · [1 + N_0(p) - 9 N_1(p) + 16 N_2(p) - 8 N_3(p)]
+ *
+ * Discrete Ricci scalar at causal-set point p, in 4 dimensions. The
+ * `(4/√6)` and N_k coefficients are dimension-specific (Benincasa-Dowker
+ * 2010 *Phys. Rev. Lett.* 104:181301 = arXiv:1001.2725); the d≠4
+ * generalization requires re-deriving them.
+ *
+ * Quantities:
+ *   - R(p):  Ricci scalar at p [L^-2]
+ *   - ℓ_P:   Planck length [L] → ℓ_P^(-2) is [L^-2]
+ *   - N_k(p): dimensionless count of inclusion-exclusion intervals
+ *             of cardinality k+2 below p
+ *   - (4/√6): dimensionless geometric prefactor
+ *
+ * Whole RHS: `(dimensionless) · [L^-2] · (dimensionless) = [L^-2]` ✓.
+ *
+ * References:
+ *   - Benincasa & Dowker 2010 *Phys. Rev. Lett.* 104:181301
+ *     (arXiv:1001.2725; canonical d=4 form);
+ *   - Sorkin 2007 "Causal Sets" (arXiv:gr-qc/0309009);
+ *   - Glaser & Surya 2014 *Class. Quantum Grav.* 31:045007
+ *     (BD action numerics on sprinkled causal sets).
+ *
+ * Status: speculative.
+ *
+ * Honest-claude scope notes:
+ *   - The Benincasa-Dowker discrete Ricci scalar is established for
+ *     d=4 causal-set continuum limits (rigorously derived in BD 2010);
+ *     the *bridge framing* — that causal-set discreteness is the UPT
+ *     microstructure of continuum spacetime — is the speculative
+ *     content.
+ *   - The Minkowski-sprinkling expectation values ⟨N_k⟩ on flat
+ *     causal sets do NOT in general make `1 + ⟨N_0⟩ - 9⟨N_1⟩ +
+ *     16⟨N_2⟩ - 8⟨N_3⟩` vanish trivially — a continuum-limit-mean
+ *     bracket-check is sensitive to BD 2010's specific sign
+ *     conventions and is omitted from the test suite. Bracket-checks
+ *     instead verify (a) coefficient extraction at unit-vector tuples,
+ *     (b) linearity in each N_k separately, (c) ℓ_P^(-2) scaling,
+ *     and (d) the algebraic-zero point at (N_0, N_1, N_2, N_3) =
+ *     (-1, 0, 0, 0).
+ *   - Encoding pattern: the dimensionless prefactor `4/√6` and the
+ *     [N_k] count combination are encoded as a single dimensionless
+ *     symbol stub `(4/√6)·bracket` — splitting them adds no
+ *     dimensional information and complicates the AST. The numerical
+ *     evaluator computes the bracket explicitly with full
+ *     coefficient fidelity.
+ *
+ * @see docs/specification/Part-II.md ("Bridge Equation 31: Causal Set Continuum Limit")
+ * @see src/bridges/index.ts BRIDGE_EQUATIONS.find(e => e.id === 31)
+ * @module bridges/equations/be-31-causal-set-bd
+ */
+import type { ExprNode, DimensionValidationReport } from '../../dimensional/validator.js';
+/**
+ * RHS of the Benincasa-Dowker d=4 discrete Ricci scalar:
+ *   (4/√6) · ℓ_P^(-2) · [1 + N_0 - 9 N_1 + 16 N_2 - 8 N_3]
+ *
+ * The dimensionless geometric prefactor (4/√6) and the dimensionless
+ * polynomial in dimensionless N_k counts are bundled into a single
+ * dimensionless symbol stub `(4/√6)·bracket`; this preserves the
+ * dimensional information without adding spurious AST structure. The
+ * numerical evaluator computes the bracket explicitly (test suite
+ * verifies coefficient extraction at unit-vector tuples).
+ */
+export declare const BE31_CAUSAL_SET_BD_RHS: ExprNode;
+/** LHS: R(p) has dimension [L^-2]. */
+export declare const BE31_CAUSAL_SET_BD_LHS: ExprNode;
+export interface BenincasaDowkerInputs {
+    /** Cardinality-2 inclusion-exclusion count N_0(p) (dimensionless integer in practice; finite real here for derivative tests). */
+    N_0: number;
+    /** Cardinality-3 count N_1(p). */
+    N_1: number;
+    /** Cardinality-4 count N_2(p). */
+    N_2: number;
+    /** Cardinality-5 count N_3(p). */
+    N_3: number;
+    /** Planck length ℓ_P (m). Must be > 0 and finite. */
+    l_P_m: number;
+}
+/**
+ * Evaluate the Benincasa-Dowker d=4 discrete Ricci scalar
+ *
+ *   R(p) = (4/√6) · ℓ_P^(-2) · [1 + N_0 - 9 N_1 + 16 N_2 - 8 N_3]
+ *
+ * @returns Ricci scalar in m^-2 (SI).
+ */
+export declare function evaluateBenincasaDowker(input: BenincasaDowkerInputs): number;
+/**
+ * Run the AST through the dimensional analyzer; both sides should be
+ * [L^-2].
+ */
+export declare function validateBE31Dimensions(): DimensionValidationReport;
+//# sourceMappingURL=be-31-causal-set-bd.d.ts.map

package/dist/bridges/equations/be-31-causal-set-bd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"be-31-causal-set-bd.d.ts","sourceRoot":"","sources":["../../../src/bridges/equations/be-31-causal-set-bd.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAkB1F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,EAAE,QASpC,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,sBAAsB,EAAE,QAAmC,CAAC;AAIzE,MAAM,WAAW,qBAAqB;IACpC,iIAAiI;IACjI,GAAG,EAAE,MAAM,CAAC;IACZ,kCAAkC;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,kCAAkC;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,kCAAkC;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAsB5E;AAID;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,yBAAyB,CASlE"}

package/dist/bridges/equations/be-31-causal-set-bd.js

@@ -0,0 +1,133 @@
+/**
+ * Bridge Equation 31 — Causal Set Continuum Limit (Benincasa-Dowker
+ * d=4 discrete Ricci scalar, post Wave I.B C3 reformulation).
+ *
+ *   R(p) = (4/√6) · ℓ_P^(-2) · [1 + N_0(p) - 9 N_1(p) + 16 N_2(p) - 8 N_3(p)]
+ *
+ * Discrete Ricci scalar at causal-set point p, in 4 dimensions. The
+ * `(4/√6)` and N_k coefficients are dimension-specific (Benincasa-Dowker
+ * 2010 *Phys. Rev. Lett.* 104:181301 = arXiv:1001.2725); the d≠4
+ * generalization requires re-deriving them.
+ *
+ * Quantities:
+ *   - R(p):  Ricci scalar at p [L^-2]
+ *   - ℓ_P:   Planck length [L] → ℓ_P^(-2) is [L^-2]
+ *   - N_k(p): dimensionless count of inclusion-exclusion intervals
+ *             of cardinality k+2 below p
+ *   - (4/√6): dimensionless geometric prefactor
+ *
+ * Whole RHS: `(dimensionless) · [L^-2] · (dimensionless) = [L^-2]` ✓.
+ *
+ * References:
+ *   - Benincasa & Dowker 2010 *Phys. Rev. Lett.* 104:181301
+ *     (arXiv:1001.2725; canonical d=4 form);
+ *   - Sorkin 2007 "Causal Sets" (arXiv:gr-qc/0309009);
+ *   - Glaser & Surya 2014 *Class. Quantum Grav.* 31:045007
+ *     (BD action numerics on sprinkled causal sets).
+ *
+ * Status: speculative.
+ *
+ * Honest-claude scope notes:
+ *   - The Benincasa-Dowker discrete Ricci scalar is established for
+ *     d=4 causal-set continuum limits (rigorously derived in BD 2010);
+ *     the *bridge framing* — that causal-set discreteness is the UPT
+ *     microstructure of continuum spacetime — is the speculative
+ *     content.
+ *   - The Minkowski-sprinkling expectation values ⟨N_k⟩ on flat
+ *     causal sets do NOT in general make `1 + ⟨N_0⟩ - 9⟨N_1⟩ +
+ *     16⟨N_2⟩ - 8⟨N_3⟩` vanish trivially — a continuum-limit-mean
+ *     bracket-check is sensitive to BD 2010's specific sign
+ *     conventions and is omitted from the test suite. Bracket-checks
+ *     instead verify (a) coefficient extraction at unit-vector tuples,
+ *     (b) linearity in each N_k separately, (c) ℓ_P^(-2) scaling,
+ *     and (d) the algebraic-zero point at (N_0, N_1, N_2, N_3) =
+ *     (-1, 0, 0, 0).
+ *   - Encoding pattern: the dimensionless prefactor `4/√6` and the
+ *     [N_k] count combination are encoded as a single dimensionless
+ *     symbol stub `(4/√6)·bracket` — splitting them adds no
+ *     dimensional information and complicates the AST. The numerical
+ *     evaluator computes the bracket explicitly with full
+ *     coefficient fidelity.
+ *
+ * @see docs/specification/Part-II.md ("Bridge Equation 31: Causal Set Continuum Limit")
+ * @see src/bridges/index.ts BRIDGE_EQUATIONS.find(e => e.id === 31)
+ * @module bridges/equations/be-31-causal-set-bd
+ */
+import { validate, validateEquation } from '../../dimensional/validator.js';
+import { DIMENSIONLESS, LENGTH, } from '../../dimensional/types.js';
+const sym = (name, dim) => ({ kind: 'symbol', name, dim });
+/**
+ * [L^-2] — inverse-area dimension for the Ricci scalar. Hand-built
+ * literal (rather than `power(LENGTH, -2)`) because `power()` produces
+ * `-0` for unaffected bases (since `0 * -2 = -0` in IEEE 754), which
+ * compares unequal under deep-strict equality even though dimensionally
+ * the value is the same. Same pattern as BE-23's RESISTIVITY literal.
+ */
+const INV_LENGTH_2 = { L: -2, M: 0, T: 0, I: 0, Theta: 0, N: 0, J: 0 };
+/**
+ * RHS of the Benincasa-Dowker d=4 discrete Ricci scalar:
+ *   (4/√6) · ℓ_P^(-2) · [1 + N_0 - 9 N_1 + 16 N_2 - 8 N_3]
+ *
+ * The dimensionless geometric prefactor (4/√6) and the dimensionless
+ * polynomial in dimensionless N_k counts are bundled into a single
+ * dimensionless symbol stub `(4/√6)·bracket`; this preserves the
+ * dimensional information without adding spurious AST structure. The
+ * numerical evaluator computes the bracket explicitly (test suite
+ * verifies coefficient extraction at unit-vector tuples).
+ */
+export const BE31_CAUSAL_SET_BD_RHS = {
+    kind: 'op', op: '*',
+    args: [
+        sym('(4/sqrt(6))*[1+N_0-9N_1+16N_2-8N_3]', DIMENSIONLESS),
+        {
+            kind: 'op', op: '^',
+            args: [sym('lP', LENGTH), sym('-2', DIMENSIONLESS)],
+        },
+    ],
+};
+/** LHS: R(p) has dimension [L^-2]. */
+export const BE31_CAUSAL_SET_BD_LHS = sym('R_p', INV_LENGTH_2);
+/**
+ * Evaluate the Benincasa-Dowker d=4 discrete Ricci scalar
+ *
+ *   R(p) = (4/√6) · ℓ_P^(-2) · [1 + N_0 - 9 N_1 + 16 N_2 - 8 N_3]
+ *
+ * @returns Ricci scalar in m^-2 (SI).
+ */
+export function evaluateBenincasaDowker(input) {
+    const { N_0, N_1, N_2, N_3, l_P_m } = input;
+    if (!Number.isFinite(N_0)) {
+        throw new RangeError(`evaluateBenincasaDowker: N_0 must be finite, got ${N_0}`);
+    }
+    if (!Number.isFinite(N_1)) {
+        throw new RangeError(`evaluateBenincasaDowker: N_1 must be finite, got ${N_1}`);
+    }
+    if (!Number.isFinite(N_2)) {
+        throw new RangeError(`evaluateBenincasaDowker: N_2 must be finite, got ${N_2}`);
+    }
+    if (!Number.isFinite(N_3)) {
+        throw new RangeError(`evaluateBenincasaDowker: N_3 must be finite, got ${N_3}`);
+    }
+    if (!Number.isFinite(l_P_m) || l_P_m <= 0) {
+        throw new RangeError(`evaluateBenincasaDowker: l_P_m must be a finite positive number, got ${l_P_m}`);
+    }
+    const bracket = 1 + N_0 - 9 * N_1 + 16 * N_2 - 8 * N_3;
+    const prefactor = 4 / Math.sqrt(6);
+    return (prefactor * bracket) / (l_P_m * l_P_m);
+}
+// --- Self-validation ---
+/**
+ * Run the AST through the dimensional analyzer; both sides should be
+ * [L^-2].
+ */
+export function validateBE31Dimensions() {
+    const eq = validateEquation(BE31_CAUSAL_SET_BD_LHS, BE31_CAUSAL_SET_BD_RHS);
+    const lhs = validate(BE31_CAUSAL_SET_BD_LHS);
+    const rhs = validate(BE31_CAUSAL_SET_BD_RHS);
+    return {
+        ok: eq.ok,
+        lhsDim: lhs.inferredDimension,
+        rhsDim: rhs.inferredDimension,
+    };
+}
+//# sourceMappingURL=be-31-causal-set-bd.js.map

package/dist/bridges/equations/be-31-causal-set-bd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"be-31-causal-set-bd.js","sourceRoot":"","sources":["../../../src/bridges/equations/be-31-causal-set-bd.ts"],"names":[],"mappings":"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"}

package/dist/bridges/equations/be-32-quantum-reference-frame.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Bridge Equation 32 — Quantum Reference Frame (QRF) overlap probability.
+ *
+ * Original (operator-valued) form:
+ *
+ *   |ψ⟩_B = ∫ dg U(g) |ψ⟩_A ⊗ |g⟩_frame
+ *
+ * which is operator-valued and, for non-compact symmetry groups, lacks
+ * a normalisable Haar measure (current `tractability_class:
+ * 'formally-divergent'`).
+ *
+ * Encoded scalar reduction (this module): the frame-invariant
+ * Born-rule overlap probability between two states related by a
+ * (single, implicit) frame transformation U(g):
+ *
+ *   P_overlap = |⟨ψ_A | U(g) | ψ_B⟩|² = c² + s²
+ *
+ * where
+ *   c = Re ⟨ψ_A | U(g) | ψ_B⟩,
+ *   s = Im ⟨ψ_A | U(g) | ψ_B⟩.
+ *
+ * P_overlap is dimensionless and lies in [0, 1] for normalised states
+ * (Born rule). This pins the canonical operationally-meaningful scalar
+ * without committing to a specific symmetry group or measure.
+ *
+ * References:
+ *   - Giacomini, Castro-Ruiz & Brukner 2019, Nat. Commun. 10:494
+ *     (arXiv:1712.07207): "Quantum mechanics and the covariance of
+ *     physical laws in quantum reference frames".
+ *   - Vanrietvelde, Hoehn, Giacomini & Castro-Ruiz 2020, Quantum 4:225
+ *     (arXiv:1809.00556): "A change of perspective: switching quantum
+ *     reference frames via a perspective-neutral framework".
+ *   - Bartlett, Rudolph & Spekkens 2007, Rev. Mod. Phys. 79:555
+ *     (arXiv:quant-ph/0610030): "Reference frames, superselection
+ *     rules, and quantum information".
+ *
+ * Status: speculative. The Born-rule probability `|⟨ψ_A|U(g)|ψ_B⟩|²`
+ * is itself a textbook scalar — what remains speculative is the
+ * QRF-bridge framing of BE-32 in this catalog (which gravitational /
+ * relational structure the U(g) corresponds to). The encoding pins
+ * the math; the QRF-bridge interpretation is the speculative content.
+ *
+ * Honest-claude scope notes:
+ *   - We encode the Born-rule probability for a single (implicit)
+ *     group element g. The original group-average `∫ dg ...` is
+ *     deferred — it would require committing to a specific symmetry
+ *     group and a Haar regulator (or an alternative regulator on a
+ *     non-compact group), neither of which is in BE-32 scope.
+ *   - The operator-valued U(g) is collapsed to its symbolic real and
+ *     imaginary matrix-element components c and s. The AST therefore
+ *     does not see the group structure; it only sees two dimensionless
+ *     real numbers feeding `c² + s²`.
+ *   - Born-rule guard: the numerical evaluator rejects `c² + s² > 1`
+ *     (within a small floating-point tolerance) because that would
+ *     mean the inputs do not correspond to overlap components of a
+ *     normalised state — a signal that the caller has provided
+ *     non-physical inputs rather than a genuine derived overlap.
+ *
+ * @see docs/specification/Part-II.md ("Bridge Equation 32: Quantum Reference Frame")
+ * @see src/bridges/index.ts BRIDGE_EQUATIONS.find(e => e.id === 32)
+ * @module bridges/equations/be-32-quantum-reference-frame
+ */
+import type { ExprNode, DimensionValidationReport } from '../../dimensional/validator.js';
+/**
+ * Lemma AST: c² where c = Re ⟨ψ_A | U(g) | ψ_B⟩. Both factors are
+ * the same dimensionless symbol, so the product is dimensionless.
+ */
+export declare const BE32_REAL_PART_SQUARED: ExprNode;
+/**
+ * Lemma AST: s² where s = Im ⟨ψ_A | U(g) | ψ_B⟩. Dimensionless by
+ * construction (matrix elements of a unitary between normalised
+ * vectors).
+ */
+export declare const BE32_IMAG_PART_SQUARED: ExprNode;
+/**
+ * RHS of `P_overlap = c² + s²` as a typed ExprNode tree. Both
+ * summands are dimensionless, so the sum is dimensionless.
+ */
+export declare const BE32_QRF_OVERLAP_RHS: ExprNode;
+/** LHS: P_overlap is the Born-rule probability — dimensionless ∈ [0,1]. */
+export declare const BE32_QRF_OVERLAP_LHS: ExprNode;
+export interface QRFOverlapInputs {
+    /**
+     * Real part of ⟨ψ_A | U(g) | ψ_B⟩. Unitless; physically ∈ [-1, 1]
+     * for normalised states. Must be finite.
+     */
+    real_part: number;
+    /**
+     * Imaginary part of ⟨ψ_A | U(g) | ψ_B⟩. Unitless; physically
+     * ∈ [-1, 1] for normalised states. Must be finite.
+     */
+    imag_part: number;
+}
+/**
+ * Evaluate P_overlap = |⟨ψ_A | U(g) | ψ_B⟩|² = c² + s².
+ *
+ * Honest-claude:
+ *   - Returns the scalar Born-rule probability for a single (implicit)
+ *     group element g. There is no group average / `∫ dg` — see the
+ *     module-header scope notes.
+ *   - Throws RangeError on non-finite inputs and on results that
+ *     exceed 1 by more than `BORN_RULE_EPS` (a Born-rule violation
+ *     guard catching obviously non-physical caller inputs).
+ *
+ * @returns P_overlap ∈ [0, 1] (dimensionless probability).
+ */
+export declare function evaluateQRFOverlap(input: QRFOverlapInputs): number;
+/**
+ * Run the AST through the dimensional analyzer; LHS and RHS should
+ * both be DIMENSIONLESS.
+ */
+export declare function validateBE32Dimensions(): DimensionValidationReport;
+//# sourceMappingURL=be-32-quantum-reference-frame.d.ts.map

package/dist/bridges/equations/be-32-quantum-reference-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"be-32-quantum-reference-frame.d.ts","sourceRoot":"","sources":["../../../src/bridges/equations/be-32-quantum-reference-frame.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAQ1F;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAMpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAMpC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAMlC,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,EAAE,QAA0C,CAAC;AAY9E,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAqBlE;AAID;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,yBAAyB,CASlE"}