universal-physics-tensor 0.5.0 → 0.7.0

package/dist/dimensional/einstein-equation.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Einstein field equation AST node (v0.6.0 Phase 2, Task 2.3).
+ *
+ * Represents the predicate
+ *
+ *     G_μν + Λ g_μν = (8πG/c⁴) T_μν
+ *
+ * as a first-class structural node in the ExprNode union. The node is a
+ * predicate (an equation), not a value-producing expression — it validates
+ * the three structural requirements (Decision #3):
+ *
+ *   1. **Free-index agreement** — G_μν and T_μν must be rank-(0,2) lower-lower
+ *      with the SAME index labels.
+ *   2. **Per-component dim equality** — each term reduces to [L⁻²]:
+ *        G_μν ~ [L⁻²]
+ *        (8πG/c⁴) T_μν ~ [T²·M⁻¹·L⁻¹] · [M·L⁻¹·T⁻²] = [L⁻²]
+ *        Λ g_μν ~ [L⁻²] · dimensionless = [L⁻²]
+ *   3. **Symmetry agreement** — both sides symmetric in (μ,ν). T_μν has
+ *      `symmetry: 'symmetric'`; G_μν is symmetric by construction.
+ *
+ * The coupling constant `8πG/c⁴` is represented symbolically by the tag
+ * `coupling: 'einstein'` (Decision #3). No inline numeric value — mirrors
+ * the constants-discipline requirement.
+ *
+ * @module dimensional/einstein-equation
+ */
+import type { Dimension } from './types.js';
+import type { MetricTensorNode } from './metric-validators.js';
+import type { EinsteinTensorNode } from './curvature.js';
+import type { StressEnergyTensorNode, CosmologicalConstantNode } from './stress-energy-validators.js';
+/**
+ * AST node for the Einstein field equation G_μν + Λ g_μν = (8πG/c⁴) T_μν.
+ *
+ * Fields:
+ *   - `lhs`          — G_μν (EinsteinTensorNode, shipped in v0.5.0)
+ *   - `cosmological` — CosmologicalConstantNode for the Λ term; null when the
+ *                      Λ-free form `G_μν = (8πG/c⁴) T_μν` is intended
+ *                      (Decision #11: null = Λ-omitted, not Λ=0).
+ *   - `metric`       — g_μν for the `Λ g_μν` cosmological term.
+ *   - `rhs`          — T_μν (StressEnergyTensorNode).
+ *   - `coupling`     — tag `'einstein'` representing 8πG/c⁴ (symbolic only).
+ *
+ * @public
+ */
+export interface EinsteinFieldEquationNode {
+    readonly kind: 'einstein-equation';
+    readonly lhs: EinsteinTensorNode;
+    readonly cosmological: CosmologicalConstantNode | null;
+    readonly metric: MetricTensorNode;
+    readonly rhs: StressEnergyTensorNode;
+    readonly coupling: 'einstein';
+}
+/**
+ * Result of validating an EinsteinFieldEquationNode.
+ *
+ * The equation as a whole is a rank-2 lower-lower tensor identity,
+ * so `freeIndices` carries the same {μ: lower, ν: lower} pair as G_μν and T_μν.
+ * `dim` is [L⁻²] — the common per-component dimension of every term.
+ *
+ * @public
+ */
+export interface EinsteinFieldEquationValidationResult {
+    readonly dim: Dimension;
+    readonly freeIndices: Map<string, {
+        upper: number;
+        lower: number;
+    }>;
+}
+/**
+ * Validate an `einstein-equation` node.
+ *
+ * Checks three predicates (Decision #3):
+ *
+ * 1. **Free-index agreement** — G_μν (lhs) and T_μν (rhs) must share the
+ *    same two lower index labels (extracted from EinsteinTensorNode's embedded
+ *    Riemann, following the Carroll Eq. 3.91 contraction convention).
+ *    Throws an Error with "index label" in the message on mismatch.
+ *
+ * 2. **Per-component dim equality** — T_μν.componentDim must equal
+ *    [M·L⁻¹·T⁻²] so that (8πG/c⁴)·T_μν ~ [L⁻²]. Throws an Error with
+ *    "dimension" in the message on mismatch.
+ *
+ * 3. **Symmetry agreement** — T_μν must have `symmetry: 'symmetric'`. Throws
+ *    an Error with "symmetry" in the message if not.
+ *
+ * Note: `lhs.riemann` structural validation is intentionally deferred to the
+ * `einstein-tensor` case arm in `validator.ts::infer()` — this function is
+ * a pure predicate-level check, not a full recursive walk.
+ *
+ * @example
+ * ```typescript
+ * import { validateEinsteinFieldEquation } from 'universal-physics-tensor';
+ * import type {
+ *   EinsteinFieldEquationNode,
+ *   EinsteinTensorNode,
+ *   StressEnergyTensorNode,
+ * } from 'universal-physics-tensor';
+ *
+ * // Minimal vacuum EFE node (G_μν = κ T_μν with T = perfect-fluid)
+ * const efeNode: EinsteinFieldEquationNode = {
+ *   kind: 'einstein-equation',
+ *   lhs: { ... } as EinsteinTensorNode,    // G_μν from einstein()
+ *   cosmological: null,                     // Λ = 0
+ *   metric: { kind: 'metric-tensor', ... },
+ *   rhs: {
+ *     kind: 'stress-energy-tensor',
+ *     indices: [
+ *       { label: 'mu', variance: 'lower' },
+ *       { label: 'nu', variance: 'lower' },
+ *     ],
+ *     fluidType: 'perfect-fluid',
+ *     symmetry: 'symmetric',
+ *     componentDim: { L: -1, M: 1, T: -2, I: 0, Theta: 0, N: 0, J: 0 },
+ *   },
+ *   coupling: 'einstein',
+ * };
+ *
+ * const result = validateEinsteinFieldEquation(efeNode);
+ * // result.dim = { L: -2, M: 0, T: 0, ... }  ([L⁻²])
+ * // result.freeIndices.get('mu') = { upper: 0, lower: 1 }
+ * ```
+ *
+ * @public
+ */
+export declare function validateEinsteinFieldEquation(node: EinsteinFieldEquationNode): EinsteinFieldEquationValidationResult;
+//# sourceMappingURL=einstein-equation.d.ts.map

package/dist/dimensional/einstein-equation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"einstein-equation.d.ts","sourceRoot":"","sources":["../../src/dimensional/einstein-equation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAWtG;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,GAAG,EAAE,kBAAkB,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,wBAAwB,GAAG,IAAI,CAAC;IACvD,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,sBAAsB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,qCAAqC;IACpD,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrE;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,yBAAyB,GAC9B,qCAAqC,CA2CvC"}

package/dist/dimensional/einstein-equation.js

@@ -0,0 +1,122 @@
+/**
+ * Einstein field equation AST node (v0.6.0 Phase 2, Task 2.3).
+ *
+ * Represents the predicate
+ *
+ *     G_μν + Λ g_μν = (8πG/c⁴) T_μν
+ *
+ * as a first-class structural node in the ExprNode union. The node is a
+ * predicate (an equation), not a value-producing expression — it validates
+ * the three structural requirements (Decision #3):
+ *
+ *   1. **Free-index agreement** — G_μν and T_μν must be rank-(0,2) lower-lower
+ *      with the SAME index labels.
+ *   2. **Per-component dim equality** — each term reduces to [L⁻²]:
+ *        G_μν ~ [L⁻²]
+ *        (8πG/c⁴) T_μν ~ [T²·M⁻¹·L⁻¹] · [M·L⁻¹·T⁻²] = [L⁻²]
+ *        Λ g_μν ~ [L⁻²] · dimensionless = [L⁻²]
+ *   3. **Symmetry agreement** — both sides symmetric in (μ,ν). T_μν has
+ *      `symmetry: 'symmetric'`; G_μν is symmetric by construction.
+ *
+ * The coupling constant `8πG/c⁴` is represented symbolically by the tag
+ * `coupling: 'einstein'` (Decision #3). No inline numeric value — mirrors
+ * the constants-discipline requirement.
+ *
+ * @module dimensional/einstein-equation
+ */
+import { validateFreeIndexLabelMatch, validateComponentDimension, validateTensorSymmetry, } from './field-equation-helpers.js';
+// Expected per-component dimension of every term: [L⁻²].
+const DIM_L_INV2 = { L: -2, M: 0, T: 0, I: 0, Theta: 0, N: 0, J: 0 };
+// Expected dimension of T_μν components: [M·L⁻¹·T⁻²] (energy density / Pa).
+// (8πG/c⁴) ~ [T²·M⁻¹·L⁻¹]; product = [M·L⁻¹·T⁻²] × [T²·M⁻¹·L⁻¹] = [L⁻²] ✓
+const DIM_T_MUV = { L: -1, M: 1, T: -2, I: 0, Theta: 0, N: 0, J: 0 };
+/**
+ * Extract the free-index labels from an EinsteinTensorNode.
+ *
+ * The Einstein tensor's free indices come from its embedded Riemann's
+ * lowerIndices[0] (σ slot) and lowerIndices[2] (ν slot) — the surviving
+ * indices after the Carroll Eq. 3.91 contraction. These become G_μν's
+ * own μ_out and ν_out labels.
+ */
+function einsteinFreeIndexLabels(lhs) {
+    const mu = lhs.riemann.lowerIndices[0].label;
+    const nu = lhs.riemann.lowerIndices[2].label;
+    return [mu, nu];
+}
+/**
+ * Validate an `einstein-equation` node.
+ *
+ * Checks three predicates (Decision #3):
+ *
+ * 1. **Free-index agreement** — G_μν (lhs) and T_μν (rhs) must share the
+ *    same two lower index labels (extracted from EinsteinTensorNode's embedded
+ *    Riemann, following the Carroll Eq. 3.91 contraction convention).
+ *    Throws an Error with "index label" in the message on mismatch.
+ *
+ * 2. **Per-component dim equality** — T_μν.componentDim must equal
+ *    [M·L⁻¹·T⁻²] so that (8πG/c⁴)·T_μν ~ [L⁻²]. Throws an Error with
+ *    "dimension" in the message on mismatch.
+ *
+ * 3. **Symmetry agreement** — T_μν must have `symmetry: 'symmetric'`. Throws
+ *    an Error with "symmetry" in the message if not.
+ *
+ * Note: `lhs.riemann` structural validation is intentionally deferred to the
+ * `einstein-tensor` case arm in `validator.ts::infer()` — this function is
+ * a pure predicate-level check, not a full recursive walk.
+ *
+ * @example
+ * ```typescript
+ * import { validateEinsteinFieldEquation } from 'universal-physics-tensor';
+ * import type {
+ *   EinsteinFieldEquationNode,
+ *   EinsteinTensorNode,
+ *   StressEnergyTensorNode,
+ * } from 'universal-physics-tensor';
+ *
+ * // Minimal vacuum EFE node (G_μν = κ T_μν with T = perfect-fluid)
+ * const efeNode: EinsteinFieldEquationNode = {
+ *   kind: 'einstein-equation',
+ *   lhs: { ... } as EinsteinTensorNode,    // G_μν from einstein()
+ *   cosmological: null,                     // Λ = 0
+ *   metric: { kind: 'metric-tensor', ... },
+ *   rhs: {
+ *     kind: 'stress-energy-tensor',
+ *     indices: [
+ *       { label: 'mu', variance: 'lower' },
+ *       { label: 'nu', variance: 'lower' },
+ *     ],
+ *     fluidType: 'perfect-fluid',
+ *     symmetry: 'symmetric',
+ *     componentDim: { L: -1, M: 1, T: -2, I: 0, Theta: 0, N: 0, J: 0 },
+ *   },
+ *   coupling: 'einstein',
+ * };
+ *
+ * const result = validateEinsteinFieldEquation(efeNode);
+ * // result.dim = { L: -2, M: 0, T: 0, ... }  ([L⁻²])
+ * // result.freeIndices.get('mu') = { upper: 0, lower: 1 }
+ * ```
+ *
+ * @public
+ */
+export function validateEinsteinFieldEquation(node) {
+    // v0.7 follow-up Phase 0 (`docs/architecture/v0.7-tensor-equation-node-
+    // design-note.md`): the three predicates below are now thin
+    // delegations to `field-equation-helpers.ts`. Behavior preserved —
+    // error messages contain the same "index label" / "dimension" /
+    // "symmetry" keywords any test pattern-matches against.
+    const [lhsMu, lhsNu] = einsteinFreeIndexLabels(node.lhs);
+    // ── Predicate 1: free-index label agreement ───────────────────────────────
+    validateFreeIndexLabelMatch('EinsteinFieldEquationNode', 'G_μν', [lhsMu, lhsNu], 'T_μν', [node.rhs.indices[0].label, node.rhs.indices[1].label]);
+    // ── Predicate 2: per-component dim equality ────────────────────────────────
+    validateComponentDimension('EinsteinFieldEquationNode', 'T_μν componentDim', node.rhs.componentDim, DIM_T_MUV, `(should be [M·L⁻¹·T⁻²] / energy density so that (8πG/c⁴)·T_μν ~ [L⁻²]; ` +
+        `per-component dim of every EFE term must reduce to [L⁻²]).`);
+    // ── Predicate 3: symmetry agreement ───────────────────────────────────────
+    validateTensorSymmetry('EinsteinFieldEquationNode', 'T_μν', node.rhs.symmetry, 'symmetric', `Both sides of the EFE are symmetric in (μ,ν).`);
+    // All predicates passed — return the equation's rank-2 lower-lower identity.
+    const freeIndices = new Map();
+    freeIndices.set(lhsMu, { upper: 0, lower: 1 });
+    freeIndices.set(lhsNu, { upper: 0, lower: 1 });
+    return { dim: DIM_L_INV2, freeIndices };
+}
+//# sourceMappingURL=einstein-equation.js.map

package/dist/dimensional/einstein-equation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"einstein-equation.js","sourceRoot":"","sources":["../../src/dimensional/einstein-equation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAOH,OAAO,EACL,2BAA2B,EAC3B,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AA2CrC,yDAAyD;AACzD,MAAM,UAAU,GAAc,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAEhF,4EAA4E;AAC5E,0EAA0E;AAC1E,MAAM,SAAS,GAAc,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAEhF;;;;;;;GAOG;AACH,SAAS,uBAAuB,CAAC,GAAuB;IACtD,MAAM,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC7C,MAAM,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC7C,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAM,UAAU,6BAA6B,CAC3C,IAA+B;IAE/B,wEAAwE;IACxE,4DAA4D;IAC5D,mEAAmE;IACnE,gEAAgE;IAChE,wDAAwD;IAExD,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,uBAAuB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEzD,6EAA6E;IAC7E,2BAA2B,CACzB,2BAA2B,EAC3B,MAAM,EACN,CAAC,KAAK,EAAE,KAAK,CAAC,EACd,MAAM,EACN,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CACvD,CAAC;IAEF,8EAA8E;IAC9E,0BAA0B,CACxB,2BAA2B,EAC3B,mBAAmB,EACnB,IAAI,CAAC,GAAG,CAAC,YAAY,EACrB,SAAS,EACT,yEAAyE;QACvE,4DAA4D,CAC/D,CAAC;IAEF,6EAA6E;IAC7E,sBAAsB,CACpB,2BAA2B,EAC3B,MAAM,EACN,IAAI,CAAC,GAAG,CAAC,QAAQ,EACjB,WAAW,EACX,+CAA+C,CAChD,CAAC;IAEF,6EAA6E;IAC7E,MAAM,WAAW,GAAG,IAAI,GAAG,EAA4C,CAAC;IACxE,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/C,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAE/C,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC;AAC1C,CAAC"}

package/dist/dimensional/field-equation-helpers.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared validation helpers for field-equation predicate AST nodes
+ * (`EinsteinFieldEquationNode`, and future `MaxwellEquationNode`,
+ * `KleinGordonEquationNode`, etc.).
+ *
+ * Per `docs/architecture/v0.7-tensor-equation-node-design-note.md`
+ * Phase 0 — extract the 3 invariant checks from
+ * `validateEinsteinFieldEquation` so future field equations get
+ * them for free, instead of copy-pasting the predicate bodies.
+ * Investment-upfront pattern: same shape as v0.6.1's
+ * validator-registry refactor.
+ *
+ * Three helpers, all behavior-preserving extractions:
+ *
+ *   - `validateFreeIndexLabelMatch` — checks lhs and rhs carry
+ *     the same free-index labels in the same order. Generic over
+ *     rank (works for rank-1 Maxwell `∇_μ F^{μν}`, rank-2 EFE,
+ *     etc.).
+ *
+ *   - `validateComponentDimension` — checks a tensor's
+ *     `componentDim` matches an expected `Dimension`. Generic
+ *     over which tensor and what equation context.
+ *
+ *   - `validateTensorSymmetry` — checks a tensor's `symmetry`
+ *     field equals an expected value. Generic over tensor +
+ *     equation context.
+ *
+ * @module dimensional/field-equation-helpers
+ */
+import type { Dimension } from './types.js';
+/**
+ * Assert that the LHS and RHS of a field-equation predicate carry
+ * the same free-index labels in the same order.
+ *
+ * Throws `Error` with `"index label"` in the message (matches the
+ * existing `validateEinsteinFieldEquation` error prose, so any
+ * test pattern-matching that string stays green).
+ *
+ * @param equationKind - Discriminator for the error message
+ *   (e.g., `'EinsteinFieldEquationNode'`, `'MaxwellEquationNode'`).
+ * @param lhsName - Human label for the LHS in the error (e.g., `'G_μν'`).
+ * @param lhsLabels - Free-index labels from the LHS, in axis order.
+ * @param rhsName - Human label for the RHS (e.g., `'T_μν'`).
+ * @param rhsLabels - Free-index labels from the RHS, in axis order.
+ *
+ * @internal
+ */
+export declare function validateFreeIndexLabelMatch(equationKind: string, lhsName: string, lhsLabels: ReadonlyArray<string>, rhsName: string, rhsLabels: ReadonlyArray<string>): void;
+/**
+ * Assert that an `actual: Dimension` equals an `expected: Dimension`
+ * across all seven base SI axes (L, M, T, I, Theta, N, J).
+ *
+ * Throws `Error` with `"dimension"` in the message (matches the
+ * existing error prose convention).
+ *
+ * @param equationKind - Discriminator (e.g., `'EinsteinFieldEquationNode'`).
+ * @param tensorName - Human label for the tensor being checked
+ *   (e.g., `'T_μν componentDim'`).
+ * @param actual - The actual `Dimension` from the AST node.
+ * @param expected - The expected `Dimension`.
+ * @param explanation - Optional trailing message explaining why
+ *   this dimension is required (e.g., `"so that (8πG/c⁴)·T_μν ~ [L⁻²]"`).
+ *
+ * @internal
+ */
+export declare function validateComponentDimension(equationKind: string, tensorName: string, actual: Dimension, expected: Dimension, explanation?: string): void;
+/**
+ * Assert that a tensor's `symmetry` field equals `expected`.
+ *
+ * Throws `Error` with `"symmetry"` in the message.
+ *
+ * @param equationKind - Discriminator (e.g., `'EinsteinFieldEquationNode'`).
+ * @param tensorName - Human label (e.g., `'T_μν'`).
+ * @param actual - The tensor's actual `symmetry` value.
+ * @param expected - The required `symmetry` value (e.g., `'symmetric'`).
+ * @param explanation - Optional trailing message (e.g., `"Both sides of
+ *   the EFE are symmetric in (μ,ν)"`).
+ *
+ * @internal
+ */
+export declare function validateTensorSymmetry(equationKind: string, tensorName: string, actual: string, expected: string, explanation?: string): void;
+//# sourceMappingURL=field-equation-helpers.d.ts.map

package/dist/dimensional/field-equation-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-equation-helpers.d.ts","sourceRoot":"","sources":["../../src/dimensional/field-equation-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAM5C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,EAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,GAC/B,IAAI,CAmBN;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,SAAS,EACnB,WAAW,CAAC,EAAE,MAAM,GACnB,IAAI,CAgBN;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,GACnB,IAAI,CAQN"}

package/dist/dimensional/field-equation-helpers.js

@@ -0,0 +1,123 @@
+/**
+ * Shared validation helpers for field-equation predicate AST nodes
+ * (`EinsteinFieldEquationNode`, and future `MaxwellEquationNode`,
+ * `KleinGordonEquationNode`, etc.).
+ *
+ * Per `docs/architecture/v0.7-tensor-equation-node-design-note.md`
+ * Phase 0 — extract the 3 invariant checks from
+ * `validateEinsteinFieldEquation` so future field equations get
+ * them for free, instead of copy-pasting the predicate bodies.
+ * Investment-upfront pattern: same shape as v0.6.1's
+ * validator-registry refactor.
+ *
+ * Three helpers, all behavior-preserving extractions:
+ *
+ *   - `validateFreeIndexLabelMatch` — checks lhs and rhs carry
+ *     the same free-index labels in the same order. Generic over
+ *     rank (works for rank-1 Maxwell `∇_μ F^{μν}`, rank-2 EFE,
+ *     etc.).
+ *
+ *   - `validateComponentDimension` — checks a tensor's
+ *     `componentDim` matches an expected `Dimension`. Generic
+ *     over which tensor and what equation context.
+ *
+ *   - `validateTensorSymmetry` — checks a tensor's `symmetry`
+ *     field equals an expected value. Generic over tensor +
+ *     equation context.
+ *
+ * @module dimensional/field-equation-helpers
+ */
+// ---------------------------------------------------------------------------
+// Helper 1 — Free-index label agreement
+// ---------------------------------------------------------------------------
+/**
+ * Assert that the LHS and RHS of a field-equation predicate carry
+ * the same free-index labels in the same order.
+ *
+ * Throws `Error` with `"index label"` in the message (matches the
+ * existing `validateEinsteinFieldEquation` error prose, so any
+ * test pattern-matching that string stays green).
+ *
+ * @param equationKind - Discriminator for the error message
+ *   (e.g., `'EinsteinFieldEquationNode'`, `'MaxwellEquationNode'`).
+ * @param lhsName - Human label for the LHS in the error (e.g., `'G_μν'`).
+ * @param lhsLabels - Free-index labels from the LHS, in axis order.
+ * @param rhsName - Human label for the RHS (e.g., `'T_μν'`).
+ * @param rhsLabels - Free-index labels from the RHS, in axis order.
+ *
+ * @internal
+ */
+export function validateFreeIndexLabelMatch(equationKind, lhsName, lhsLabels, rhsName, rhsLabels) {
+    if (lhsLabels.length !== rhsLabels.length) {
+        throw new Error(`${equationKind}: index label rank mismatch — LHS ${lhsName} has ` +
+            `${lhsLabels.length} free indices (${lhsLabels.join(', ')}) but RHS ` +
+            `${rhsName} has ${rhsLabels.length} (${rhsLabels.join(', ')}). ` +
+            `Both sides must carry the same rank.`);
+    }
+    for (let i = 0; i < lhsLabels.length; i++) {
+        if (lhsLabels[i] !== rhsLabels[i]) {
+            throw new Error(`${equationKind}: index label mismatch — LHS ${lhsName} has free ` +
+                `indices (${lhsLabels.join(', ')}) but RHS ${rhsName} has ` +
+                `(${rhsLabels.join(', ')}). Both sides must carry the same lower ` +
+                `index labels in the same axis order.`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helper 2 — Per-component dimensional equality
+// ---------------------------------------------------------------------------
+/**
+ * Assert that an `actual: Dimension` equals an `expected: Dimension`
+ * across all seven base SI axes (L, M, T, I, Theta, N, J).
+ *
+ * Throws `Error` with `"dimension"` in the message (matches the
+ * existing error prose convention).
+ *
+ * @param equationKind - Discriminator (e.g., `'EinsteinFieldEquationNode'`).
+ * @param tensorName - Human label for the tensor being checked
+ *   (e.g., `'T_μν componentDim'`).
+ * @param actual - The actual `Dimension` from the AST node.
+ * @param expected - The expected `Dimension`.
+ * @param explanation - Optional trailing message explaining why
+ *   this dimension is required (e.g., `"so that (8πG/c⁴)·T_μν ~ [L⁻²]"`).
+ *
+ * @internal
+ */
+export function validateComponentDimension(equationKind, tensorName, actual, expected, explanation) {
+    if (actual.L !== expected.L ||
+        actual.M !== expected.M ||
+        actual.T !== expected.T ||
+        actual.I !== expected.I ||
+        actual.Theta !== expected.Theta ||
+        actual.N !== expected.N ||
+        actual.J !== expected.J) {
+        const tail = explanation ? ` ${explanation}` : '';
+        throw new Error(`${equationKind}: dimension mismatch — ${tensorName} must be ` +
+            `${JSON.stringify(expected)} but got ${JSON.stringify(actual)}.${tail}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Helper 3 — Tensor symmetry agreement
+// ---------------------------------------------------------------------------
+/**
+ * Assert that a tensor's `symmetry` field equals `expected`.
+ *
+ * Throws `Error` with `"symmetry"` in the message.
+ *
+ * @param equationKind - Discriminator (e.g., `'EinsteinFieldEquationNode'`).
+ * @param tensorName - Human label (e.g., `'T_μν'`).
+ * @param actual - The tensor's actual `symmetry` value.
+ * @param expected - The required `symmetry` value (e.g., `'symmetric'`).
+ * @param explanation - Optional trailing message (e.g., `"Both sides of
+ *   the EFE are symmetric in (μ,ν)"`).
+ *
+ * @internal
+ */
+export function validateTensorSymmetry(equationKind, tensorName, actual, expected, explanation) {
+    if (actual !== expected) {
+        const tail = explanation ? ` ${explanation}` : '';
+        throw new Error(`${equationKind}: symmetry mismatch — ${tensorName} must have ` +
+            `symmetry: '${expected}' (got '${actual}').${tail}`);
+    }
+}
+//# sourceMappingURL=field-equation-helpers.js.map

package/dist/dimensional/field-equation-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-equation-helpers.js","sourceRoot":"","sources":["../../src/dimensional/field-equation-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,8EAA8E;AAC9E,wCAAwC;AACxC,8EAA8E;AAE9E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,2BAA2B,CACzC,YAAoB,EACpB,OAAe,EACf,SAAgC,EAChC,OAAe,EACf,SAAgC;IAEhC,IAAI,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CACb,GAAG,YAAY,qCAAqC,OAAO,OAAO;YAClE,GAAG,SAAS,CAAC,MAAM,kBAAkB,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY;YACrE,GAAG,OAAO,QAAQ,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK;YAChE,sCAAsC,CACvC,CAAC;IACJ,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CACb,GAAG,YAAY,gCAAgC,OAAO,YAAY;gBAClE,YAAY,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,OAAO,OAAO;gBAC3D,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,0CAA0C;gBAClE,sCAAsC,CACvC,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED,8EAA8E;AAC9E,gDAAgD;AAChD,8EAA8E;AAE9E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,0BAA0B,CACxC,YAAoB,EACpB,UAAkB,EAClB,MAAiB,EACjB,QAAmB,EACnB,WAAoB;IAEpB,IACE,MAAM,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC;QACvB,MAAM,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC;QACvB,MAAM,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC;QACvB,MAAM,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC;QACvB,MAAM,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK;QAC/B,MAAM,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC;QACvB,MAAM,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EACvB,CAAC;QACD,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CACb,GAAG,YAAY,0BAA0B,UAAU,WAAW;YAC9D,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,YAAY,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CACxE,CAAC;IACJ,CAAC;AACH,CAAC;AAED,8EAA8E;AAC9E,uCAAuC;AACvC,8EAA8E;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,sBAAsB,CACpC,YAAoB,EACpB,UAAkB,EAClB,MAAc,EACd,QAAgB,EAChB,WAAoB;IAEpB,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CACb,GAAG,YAAY,yBAAyB,UAAU,aAAa;YAC/D,cAAc,QAAQ,WAAW,MAAM,MAAM,IAAI,EAAE,CACpD,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/dimensional/friedmann-equation.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Friedmann equation AST node — modified-cosmology predicate.
+ *
+ * Per `docs/architecture/v0.7-be-x-reencoding-design-note.md`
+ * §"BE-19 — `FriedmannEquationNode` for modified-Friedmann
+ * predicates". Fourth of four BE-X structural re-encodings in the
+ * v0.7-series follow-up to the v0.6.0 deferred-bridges list.
+ *
+ * Represents the predicate
+ *
+ *     H² = (8πG/3) · ρ · [correction]
+ *
+ * where H is the Hubble parameter, ρ the cosmic energy/mass-density,
+ * and `[correction]` is a variant-tagged extension term. The classical
+ * FRW form takes `correction = null`; modified-cosmology variants
+ * (LQC bounce, Randall-Sundrum brane, DGP, dRGT massive gravity)
+ * tag their correction with a `variant` discriminator so consumers
+ * can pattern-match on which cosmological regime the equation
+ * occupies.
+ *
+ * Discriminator vocabulary:
+ *
+ *   - `'classical'` — canonical FRW `H² = (8πG/3) ρ` (the [-k/a²]
+ *     and [Λ/3] terms ride along as additive scalars, not the
+ *     `correction` slot). `correction` MUST be `null`.
+ *   - `'lqc'` — Loop Quantum Cosmology bounce `(1 − ρ/ρ_crit)`. The
+ *     correction is a DIMENSIONLESS multiplicative factor.
+ *   - `'brane'` — Randall-Sundrum brane-tension `(1 + ρ/(2σ))`. Also
+ *     dimensionless multiplicative.
+ *   - `'dgp'` — Dvali-Gabadadze-Porrati 5D-crossover `±H/r_c`. The
+ *     `correction` slot holds a stub for the additional scale; this
+ *     variant signals "5D structure present" — fine-grained dim
+ *     discipline left for future BE-NN landing.
+ *   - `'massive'` — dRGT massive-gravity graviton-mass term. The
+ *     `correction` slot holds the graviton-mass^2 contribution; dim
+ *     discipline left for future BE-NN landing.
+ *
+ * The variant discriminator is the load-bearing structural fact:
+ * future modified-cosmology bridges (brane, DGP, dRGT) land as new
+ * `BridgeEquation` entries that produce `FriedmannEquationNode`s
+ * with the appropriate variant tag, instead of each inventing a
+ * separate AST primitive.
+ *
+ * References:
+ *   - Mukhanov, *Physical Foundations of Cosmology* (2005), §2.1
+ *     for the canonical FRW Friedmann equation derivation.
+ *   - Ashtekar & Singh, *Loop Quantum Cosmology: A Status Report*
+ *     (2011), arXiv:1108.0893 — for the LQC `(1 − ρ/ρ_crit)` bounce
+ *     factor; the canonical reference for the `'lqc'` variant
+ *     consumed by BE-19.
+ *
+ * Status: PREDICATE node like `EinsteinFieldEquationNode` and
+ * `KleinGordonEquationNode` — not a value-producing expression.
+ * Numerical evaluation of a specific FRW history is out of scope
+ * (numerical evaluators live alongside per-bridge encodings — e.g.
+ * `evaluateQuantumBounce` in `src/bridges/equations/be-19-quantum-bounce.ts`).
+ *
+ * @module dimensional/friedmann-equation
+ */
+import type { Dimension } from './types.js';
+import type { ScalarFieldNode } from './klein-gordon-equation.js';
+/**
+ * Tag for the cosmological regime a `FriedmannEquationNode`
+ * represents. Each variant identifies a structural pattern of
+ * deviation from canonical FRW; consumers pattern-match on this
+ * discriminator to select regime-specific downstream logic.
+ *
+ * See the module docstring for the per-variant semantics.
+ *
+ * @public
+ */
+export type FriedmannVariant = 'classical' | 'lqc' | 'brane' | 'dgp' | 'massive';
+/**
+ * AST node for the modified Friedmann equation
+ *
+ *     H² = (8πG/3) · ρ · [variant-specific correction]
+ *
+ * Fields:
+ *   - `hubble`      — H or H² as a `ScalarFieldNode`. Accepted dims
+ *                     are `[T^-1]` (H) or `[T^-2]` (H²); the validator
+ *                     does NOT square the field for you, it only
+ *                     checks the stated dim is one of the two.
+ *   - `density`     — ρ as a `ScalarFieldNode`, dim `[M·L^-3]`
+ *                     (mass-density convention, aligning with BE-19's
+ *                     existing `QUANTUM_BOUNCE_RHS` encoding).
+ *   - `correction`  — the variant-specific extension. `null` IFF
+ *                     `variant === 'classical'`. For `'lqc'`, the
+ *                     correction's dim is constrained to be
+ *                     dimensionless (the `(1 − ρ/ρ_crit)` factor).
+ *                     Other non-classical variants accept any dim
+ *                     (refinement deferred to per-bridge landing).
+ *   - `variant`     — the regime discriminator. See `FriedmannVariant`.
+ *   - `coupling`    — tag `'friedmann'` representing the symbolic
+ *                     `(8πG/3)` prefactor (no inline numeric).
+ *
+ * @public
+ */
+export interface FriedmannEquationNode {
+    readonly kind: 'friedmann-equation';
+    readonly hubble: ScalarFieldNode;
+    readonly density: ScalarFieldNode;
+    readonly correction: ScalarFieldNode | null;
+    readonly variant: FriedmannVariant;
+    readonly coupling: 'friedmann';
+}
+/**
+ * Result of validating a `FriedmannEquationNode`. Mirrors
+ * `KleinGordonEquationValidationResult` shape.
+ *
+ * @public
+ */
+export interface FriedmannEquationValidationResult {
+    /** Per-component dim of the equation — `[T^-2]` (H² shape). */
+    readonly dim: Dimension;
+    /** Empty free-indices map (rank-0 equation). */
+    readonly freeIndices: Map<string, {
+        upper: number;
+        lower: number;
+    }>;
+    /** Echo of the variant tag for downstream pattern-matching. */
+    readonly variant: FriedmannVariant;
+}
+/**
+ * Validate a `friedmann-equation` node.
+ *
+ * Predicates (mirroring the field-equation-helpers pattern):
+ *
+ *   1. **Variant discriminator** — `variant` must be one of the
+ *      known tags. Throws with `"variant"` keyword on unknown values.
+ *   2. **Classical–correction consistency** — `variant === 'classical'`
+ *      requires `correction === null`; any other variant requires
+ *      `correction !== null`. Throws with `"variant"` keyword.
+ *   3. **Free-index agreement** — trivially passes (rank-0 equation).
+ *   4. **Per-component dim equality** — `hubble.dim` must be `[T^-2]`
+ *      (H²) or `[T^-1]` (H); `density.dim` must be `[M·L^-3]`. For
+ *      `variant === 'lqc'`, `correction.dim` must be dimensionless
+ *      (the `(1 − ρ/ρ_crit)` bounce factor).
+ *   5. **Symmetry agreement** — all participants carry the trivial
+ *      `'scalar'` marker.
+ *
+ * Errors carry the keywords `"dimension"` / `"symmetry"` (from the
+ * field-equation-helpers) and `"variant"` (for discriminator /
+ * classical-consistency violations).
+ *
+ * @public
+ */
+export declare function validateFriedmannEquation(node: FriedmannEquationNode): FriedmannEquationValidationResult;
+//# sourceMappingURL=friedmann-equation.d.ts.map

package/dist/dimensional/friedmann-equation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"friedmann-equation.d.ts","sourceRoot":"","sources":["../../src/dimensional/friedmann-equation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAYlE;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GACxB,WAAW,GACX,KAAK,GACL,OAAO,GACP,KAAK,GACL,SAAS,CAAC;AAcd;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;CAChC;AAED;;;;;GAKG;AACH,MAAM,WAAW,iCAAiC;IAChD,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,gDAAgD;IAChD,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpE,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;CACpC;AAsBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,qBAAqB,GAC1B,iCAAiC,CA6FnC"}