universal-physics-tensor 0.5.1 → 0.7.1

package/dist/dimensional/klein-gordon-equation.js

@@ -0,0 +1,98 @@
+/**
+ * Klein-Gordon scalar field equation AST node.
+ *
+ * Phase 1 of the TensorEquationNode<LHS, RHS> generalization
+ * (`docs/architecture/v0.7-tensor-equation-node-design-note.md`).
+ * First new field-equation node to use the Phase 0 field-equation
+ * helpers shipped in commit `5cd860a`.
+ *
+ * Represents the predicate
+ *
+ *     (□ + m²) φ = J
+ *
+ * where `□ = g^μν ∇_μ ∇_ν` is the d'Alembertian (wave operator),
+ * `m` is the field's mass, and `J` is an optional rank-0 source
+ * (set to `null` for the homogeneous form `(□ + m²) φ = 0`).
+ *
+ * The node validates three structural requirements (mirroring
+ * `EinsteinFieldEquationNode`'s pattern):
+ *
+ *   1. **Free-index agreement** — LHS and RHS are both rank-0
+ *      (scalar). Trivial case of the rank-N invariant.
+ *   2. **Per-component dim equality** — LHS and RHS must have the
+ *      same `Dimension`. The wave-operator's component dim equals
+ *      the field's `[fieldDim] · [L^-2]`; m² has dim `[L^-2]`; so
+ *      the LHS bracket combines to `[fieldDim · L^-2]`. The source
+ *      J must match that.
+ *   3. **Symmetry agreement** — scalar fields have no symmetry
+ *      structure; both sides carry the trivial `'scalar'` marker.
+ *
+ * Note: this is a PREDICATE node like EinsteinFieldEquationNode —
+ * not a value-producing expression. Numerical evaluation of the
+ * wave-operator action on a specific field is out of scope
+ * (would require a separate `lowerKleinGordon` step like the
+ * curvature pipeline).
+ *
+ * @module dimensional/klein-gordon-equation
+ */
+import { validateFreeIndexLabelMatch, validateComponentDimension, validateTensorSymmetry, } from './field-equation-helpers.js';
+/** The dimensional contribution of `□ + m²`: `[L^-2]`. */
+const WAVE_OPERATOR_DIM_FACTOR = {
+    L: -2, M: 0, T: 0, I: 0, Theta: 0, N: 0, J: 0,
+};
+/**
+ * Compose `[field.dim] × [L^-2]` (component-wise sum of exponents).
+ */
+function composeWaveOperatorDim(fieldDim) {
+    return {
+        L: fieldDim.L + WAVE_OPERATOR_DIM_FACTOR.L,
+        M: fieldDim.M + WAVE_OPERATOR_DIM_FACTOR.M,
+        T: fieldDim.T + WAVE_OPERATOR_DIM_FACTOR.T,
+        I: fieldDim.I + WAVE_OPERATOR_DIM_FACTOR.I,
+        Theta: fieldDim.Theta + WAVE_OPERATOR_DIM_FACTOR.Theta,
+        N: fieldDim.N + WAVE_OPERATOR_DIM_FACTOR.N,
+        J: fieldDim.J + WAVE_OPERATOR_DIM_FACTOR.J,
+    };
+}
+/**
+ * Validate a `klein-gordon-equation` node.
+ *
+ * Three predicates (mirroring the field-equation-helpers pattern):
+ *
+ *   1. **Free-index agreement** — trivially passes (both sides are
+ *      rank-0; `validateFreeIndexLabelMatch` with empty arrays).
+ *   2. **Per-component dim equality** — m² and source J must
+ *      match the wave-operator's contribution.
+ *   3. **Symmetry agreement** — all participants are 'scalar'.
+ *
+ * Errors carry the keywords 'index label', 'dimension', 'symmetry'
+ * (consumers pattern-matching on the EFE error vocabulary stay
+ * green).
+ *
+ * @public
+ */
+export function validateKleinGordonEquation(node) {
+    const composedDim = composeWaveOperatorDim(node.field.dim);
+    // Predicate 1: free-index agreement (trivially: both rank-0).
+    validateFreeIndexLabelMatch('KleinGordonEquationNode', '(□+m²)φ', [], node.source ? 'J' : '0', []);
+    // Predicate 2a: m² dimension must be [L^-2] (mass-squared as a
+    // wave-operator term contributes this).
+    validateComponentDimension('KleinGordonEquationNode', 'mass term m².dim', node.mass.dim, WAVE_OPERATOR_DIM_FACTOR, 'm² is the mass-squared term in (□+m²)φ; must have dim [L^-2] to combine with the wave operator.');
+    // Predicate 2b: source J dimension must equal the composed
+    // wave-operator-acting-on-field dim. Skipped if source is null
+    // (homogeneous form).
+    if (node.source !== null) {
+        validateComponentDimension('KleinGordonEquationNode', 'source J.dim', node.source.dim, composedDim, 'J must match (□+m²)φ on the LHS, which has dim [field.dim · L^-2].');
+    }
+    // Predicate 3: symmetry agreement — all 'scalar'.
+    validateTensorSymmetry('KleinGordonEquationNode', 'field φ', node.field.symmetry, 'scalar', 'Klein-Gordon is a scalar field equation.');
+    validateTensorSymmetry('KleinGordonEquationNode', 'mass m²', node.mass.symmetry, 'scalar', 'm² is a scalar parameter.');
+    if (node.source !== null) {
+        validateTensorSymmetry('KleinGordonEquationNode', 'source J', node.source.symmetry, 'scalar', 'Klein-Gordon source J is a scalar.');
+    }
+    return {
+        dim: composedDim,
+        freeIndices: new Map(),
+    };
+}
+//# sourceMappingURL=klein-gordon-equation.js.map

package/dist/dimensional/klein-gordon-equation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"klein-gordon-equation.js","sourceRoot":"","sources":["../../src/dimensional/klein-gordon-equation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAGH,OAAO,EACL,2BAA2B,EAC3B,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AA0DrC,0DAA0D;AAC1D,MAAM,wBAAwB,GAAc;IAC1C,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;CAC9C,CAAC;AAEF;;GAEG;AACH,SAAS,sBAAsB,CAAC,QAAmB;IACjD,OAAO;QACL,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,wBAAwB,CAAC,CAAC;QAC1C,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,wBAAwB,CAAC,CAAC;QAC1C,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,wBAAwB,CAAC,CAAC;QAC1C,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,wBAAwB,CAAC,CAAC;QAC1C,KAAK,EAAE,QAAQ,CAAC,KAAK,GAAG,wBAAwB,CAAC,KAAK;QACtD,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,wBAAwB,CAAC,CAAC;QAC1C,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,wBAAwB,CAAC,CAAC;KAC3C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,2BAA2B,CACzC,IAA6B;IAE7B,MAAM,WAAW,GAAG,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAE3D,8DAA8D;IAC9D,2BAA2B,CACzB,yBAAyB,EACzB,SAAS,EACT,EAAE,EACF,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EACvB,EAAE,CACH,CAAC;IAEF,+DAA+D;IAC/D,wCAAwC;IACxC,0BAA0B,CACxB,yBAAyB,EACzB,kBAAkB,EAClB,IAAI,CAAC,IAAI,CAAC,GAAG,EACb,wBAAwB,EACxB,iGAAiG,CAClG,CAAC;IAEF,2DAA2D;IAC3D,+DAA+D;IAC/D,sBAAsB;IACtB,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;QACzB,0BAA0B,CACxB,yBAAyB,EACzB,cAAc,EACd,IAAI,CAAC,MAAM,CAAC,GAAG,EACf,WAAW,EACX,oEAAoE,CACrE,CAAC;IACJ,CAAC;IAED,kDAAkD;IAClD,sBAAsB,CACpB,yBAAyB,EACzB,SAAS,EACT,IAAI,CAAC,KAAK,CAAC,QAAQ,EACnB,QAAQ,EACR,0CAA0C,CAC3C,CAAC;IACF,sBAAsB,CACpB,yBAAyB,EACzB,SAAS,EACT,IAAI,CAAC,IAAI,CAAC,QAAQ,EAClB,QAAQ,EACR,2BAA2B,CAC5B,CAAC;IACF,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;QACzB,sBAAsB,CACpB,yBAAyB,EACzB,UAAU,EACV,IAAI,CAAC,MAAM,CAAC,QAAQ,EACpB,QAAQ,EACR,oCAAoC,CACrC,CAAC;IACJ,CAAC;IAED,OAAO;QACL,GAAG,EAAE,WAAW;QAChB,WAAW,EAAE,IAAI,GAAG,EAAE;KACvB,CAAC;AACJ,CAAC"}

package/dist/dimensional/rg-flow.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Renormalization-group (RG) flow primitives — `RGCouplingNode` +
+ * `BetaFunctionNode` (v0.7 BE-X re-encoding sprint).
+ *
+ * Encodes the structure of a Wilsonian / functional-RG flow on the
+ * space of *dimensionless* couplings. The motivating physics context
+ * is the asymptotic-safety program for quantum gravity (Reuter 1998
+ * *Phys. Rev. D* 57:971, arXiv:hep-th/9605030; Niedermaier-Reuter 2006
+ * *Living Rev. Relativity* 9:5 for the canonical review), in which RG
+ * flow on the space of dimensionless couplings `g_n = G_n(k)·k^{d_n}`
+ * is governed by polynomial β-functions
+ *
+ *     β_n(g_1, g_2, …) ≡ k ∂_k g_n
+ *
+ * and a viable UV-complete theory is signalled by the existence of a
+ * non-Gaussian fixed point `(g_1*, g_2*, …)` at which every β_n
+ * vanishes simultaneously. The structural distinction made here:
+ *
+ *   - `RGCouplingNode` represents a single dimensionless coupling
+ *     (`g`, `λ`, …) — a labelled handle, dim hardcoded to
+ *     DIMENSIONLESS for type-system symmetry with other AST nodes.
+ *   - `BetaFunctionNode` represents one β-function of a multi-coupling
+ *     flow: it carries the FULL coupling vector (the flow direction),
+ *     a `target` selector picking out which coupling's β-function this
+ *     node represents, the polynomial expression in those couplings,
+ *     and an optional UV / IR fixed-point pin.
+ *
+ * The polynomial expression is a standard `ExprNode` built from
+ * dimensionless symbols + the existing `op (+ * / ^ -)` primitives;
+ * `validateBetaFunction` delegates dimensional checking to the existing
+ * `validate()` from `validator.ts` and verifies the result reduces to
+ * DIMENSIONLESS.
+ *
+ * These primitives are NOT (yet) added to the `ExprNode` union — they
+ * live as a standalone predicate-level structure that callers compose
+ * adjacent to the existing AST. BE-39's polynomial RHS continues to be
+ * encoded as plain `op`-trees for catalog round-trip; the structural
+ * `BetaFunctionNode` wrapper supplies the higher-level RG-flow
+ * semantics on top.
+ *
+ * @module dimensional/rg-flow
+ */
+import type { ExprNode } from './validator.js';
+import type { Dimension } from './types.js';
+/**
+ * AST node for a single dimensionless RG coupling (e.g. `g`, `λ`).
+ *
+ * By RG-discipline every coupling appearing in a β-function expression
+ * is dimensionless: physical dimensionful couplings `G_n` are made
+ * dimensionless via the RG scale `k` (e.g. `g = G·k²`, `λ = Λ/k²`).
+ * The `dim` field is therefore hardcoded to `DIMENSIONLESS`; it is
+ * exposed for type-system symmetry with `{ kind: 'symbol' }` so a
+ * future ExprNode-union integration is mechanical.
+ *
+ * @public
+ */
+export interface RGCouplingNode {
+    readonly kind: 'rg-coupling';
+    /** Coupling name, e.g. `'g'`, `'lambda'`. Non-empty. */
+    readonly name: string;
+    /** Always `DIMENSIONLESS` — RG-discipline invariant. */
+    readonly dim: Dimension;
+}
+/**
+ * Construct an `RGCouplingNode` with the dimensionless invariant
+ * pre-applied. Convenience helper — callers may also build the node
+ * literal directly.
+ *
+ * @public
+ */
+export declare function rgCoupling(name: string): RGCouplingNode;
+/**
+ * Validate an `RGCouplingNode`.
+ *
+ * Predicates:
+ *   1. `name` is a non-empty string (dimension validators reject empty
+ *      labels because they make error messages unintelligible).
+ *   2. `dim` is `DIMENSIONLESS` (RG-discipline invariant; physical
+ *      dimension is absorbed into the running scale `k`).
+ *
+ * Throws an `Error` with `"name"` / `"dimension"` in the message on
+ * failure.
+ *
+ * @public
+ */
+export declare function validateRGCoupling(node: RGCouplingNode): void;
+/**
+ * AST node for a single β-function in a multi-coupling RG flow.
+ *
+ * Fields:
+ *   - `couplings` — the full coupling vector `(g_1, g_2, …)`; this is
+ *     the flow direction. Every coupling must appear here, even those
+ *     that do not enter the polynomialExpansion of this specific
+ *     β-function (so that the cross-coupling dependency structure is
+ *     captured at the type level).
+ *   - `target` — the coupling whose β-function this node represents.
+ *     MUST be one of `couplings` (by name).
+ *   - `polynomialExpansion` — the explicit β(couplings) expression as
+ *     a standard `ExprNode`. Must reduce to `DIMENSIONLESS` via the
+ *     existing `validate()`.
+ *   - `fixedPoint` — optional UV / IR fixed-point pin, one numeric
+ *     value per coupling in the same order as `couplings`. When
+ *     present, `fixedPoint.length === couplings.length` is enforced.
+ *
+ * The polynomial form follows Reuter 1998 + the Niedermaier-Reuter 2006
+ * review: each β_n is a polynomial in the dimensionless couplings,
+ * truncated at some power dictated by the chosen truncation scheme
+ * (e.g. canonical Einstein-Hilbert truncation for gravity).
+ *
+ * @public
+ */
+export interface BetaFunctionNode {
+    readonly kind: 'beta-function';
+    readonly couplings: ReadonlyArray<RGCouplingNode>;
+    readonly target: RGCouplingNode;
+    readonly polynomialExpansion: ExprNode;
+    readonly fixedPoint?: ReadonlyArray<number>;
+}
+/**
+ * Result of validating a `BetaFunctionNode`.
+ *
+ * `dim` is always `DIMENSIONLESS` (a β-function of dimensionless
+ * couplings is itself dimensionless: `β = k ∂_k g` with both `g` and
+ * `k ∂_k log(k)` dimensionless). `targetName` is the validated target
+ * coupling label, useful for downstream RG-flow assembly.
+ *
+ * @public
+ */
+export interface BetaFunctionValidationResult {
+    readonly dim: Dimension;
+    readonly targetName: string;
+}
+/**
+ * Validate a `BetaFunctionNode`.
+ *
+ * Predicates:
+ *
+ *   1. **Coupling list non-empty**: `couplings.length >= 1`. A flow
+ *      with no couplings has no β-function to define.
+ *   2. **Every coupling is well-formed**: each entry passes
+ *      `validateRGCoupling`. Names must be unique.
+ *   3. **Target ∈ couplings**: `target.name` appears in
+ *      `couplings.map(c => c.name)`. Throws an Error scoped
+ *      `'BetaFunctionNode: target …'` on miss.
+ *   4. **Polynomial dimensionless**: `validate(polynomialExpansion)`
+ *      succeeds and yields `DIMENSIONLESS`. Anything else throws with
+ *      `'dimension'` in the message.
+ *   5. **Fixed-point length match** (if `fixedPoint` is set):
+ *      `fixedPoint.length === couplings.length`. Each value must be
+ *      finite. Throws scoped `'BetaFunctionNode: fixedPoint …'` on
+ *      mismatch.
+ *
+ * @public
+ */
+export declare function validateBetaFunction(node: BetaFunctionNode): BetaFunctionValidationResult;
+//# sourceMappingURL=rg-flow.d.ts.map

package/dist/dimensional/rg-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rg-flow.d.ts","sourceRoot":"","sources":["../../src/dimensional/rg-flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAQ5C;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAEvD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAc7D;AAMD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAClD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,QAAQ,CAAC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC7C;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,gBAAgB,GACrB,4BAA4B,CAyE9B"}

package/dist/dimensional/rg-flow.js

@@ -0,0 +1,150 @@
+/**
+ * Renormalization-group (RG) flow primitives — `RGCouplingNode` +
+ * `BetaFunctionNode` (v0.7 BE-X re-encoding sprint).
+ *
+ * Encodes the structure of a Wilsonian / functional-RG flow on the
+ * space of *dimensionless* couplings. The motivating physics context
+ * is the asymptotic-safety program for quantum gravity (Reuter 1998
+ * *Phys. Rev. D* 57:971, arXiv:hep-th/9605030; Niedermaier-Reuter 2006
+ * *Living Rev. Relativity* 9:5 for the canonical review), in which RG
+ * flow on the space of dimensionless couplings `g_n = G_n(k)·k^{d_n}`
+ * is governed by polynomial β-functions
+ *
+ *     β_n(g_1, g_2, …) ≡ k ∂_k g_n
+ *
+ * and a viable UV-complete theory is signalled by the existence of a
+ * non-Gaussian fixed point `(g_1*, g_2*, …)` at which every β_n
+ * vanishes simultaneously. The structural distinction made here:
+ *
+ *   - `RGCouplingNode` represents a single dimensionless coupling
+ *     (`g`, `λ`, …) — a labelled handle, dim hardcoded to
+ *     DIMENSIONLESS for type-system symmetry with other AST nodes.
+ *   - `BetaFunctionNode` represents one β-function of a multi-coupling
+ *     flow: it carries the FULL coupling vector (the flow direction),
+ *     a `target` selector picking out which coupling's β-function this
+ *     node represents, the polynomial expression in those couplings,
+ *     and an optional UV / IR fixed-point pin.
+ *
+ * The polynomial expression is a standard `ExprNode` built from
+ * dimensionless symbols + the existing `op (+ * / ^ -)` primitives;
+ * `validateBetaFunction` delegates dimensional checking to the existing
+ * `validate()` from `validator.ts` and verifies the result reduces to
+ * DIMENSIONLESS.
+ *
+ * These primitives are NOT (yet) added to the `ExprNode` union — they
+ * live as a standalone predicate-level structure that callers compose
+ * adjacent to the existing AST. BE-39's polynomial RHS continues to be
+ * encoded as plain `op`-trees for catalog round-trip; the structural
+ * `BetaFunctionNode` wrapper supplies the higher-level RG-flow
+ * semantics on top.
+ *
+ * @module dimensional/rg-flow
+ */
+import { validate } from './validator.js';
+import { DIMENSIONLESS } from './types.js';
+import { validateComponentDimension } from './field-equation-helpers.js';
+/**
+ * Construct an `RGCouplingNode` with the dimensionless invariant
+ * pre-applied. Convenience helper — callers may also build the node
+ * literal directly.
+ *
+ * @public
+ */
+export function rgCoupling(name) {
+    return { kind: 'rg-coupling', name, dim: DIMENSIONLESS };
+}
+/**
+ * Validate an `RGCouplingNode`.
+ *
+ * Predicates:
+ *   1. `name` is a non-empty string (dimension validators reject empty
+ *      labels because they make error messages unintelligible).
+ *   2. `dim` is `DIMENSIONLESS` (RG-discipline invariant; physical
+ *      dimension is absorbed into the running scale `k`).
+ *
+ * Throws an `Error` with `"name"` / `"dimension"` in the message on
+ * failure.
+ *
+ * @public
+ */
+export function validateRGCoupling(node) {
+    if (typeof node.name !== 'string' || node.name.length === 0) {
+        throw new Error(`RGCouplingNode: invalid name — must be a non-empty string ` +
+            `(got ${JSON.stringify(node.name)}).`);
+    }
+    validateComponentDimension('RGCouplingNode', `coupling '${node.name}'`, node.dim, DIMENSIONLESS, `must be DIMENSIONLESS by RG-discipline. Physical dimension should be absorbed into the running scale k.`);
+}
+/**
+ * Validate a `BetaFunctionNode`.
+ *
+ * Predicates:
+ *
+ *   1. **Coupling list non-empty**: `couplings.length >= 1`. A flow
+ *      with no couplings has no β-function to define.
+ *   2. **Every coupling is well-formed**: each entry passes
+ *      `validateRGCoupling`. Names must be unique.
+ *   3. **Target ∈ couplings**: `target.name` appears in
+ *      `couplings.map(c => c.name)`. Throws an Error scoped
+ *      `'BetaFunctionNode: target …'` on miss.
+ *   4. **Polynomial dimensionless**: `validate(polynomialExpansion)`
+ *      succeeds and yields `DIMENSIONLESS`. Anything else throws with
+ *      `'dimension'` in the message.
+ *   5. **Fixed-point length match** (if `fixedPoint` is set):
+ *      `fixedPoint.length === couplings.length`. Each value must be
+ *      finite. Throws scoped `'BetaFunctionNode: fixedPoint …'` on
+ *      mismatch.
+ *
+ * @public
+ */
+export function validateBetaFunction(node) {
+    // ── Predicate 1: coupling list non-empty ───────────────────────────────────
+    if (node.couplings.length === 0) {
+        throw new Error(`BetaFunctionNode: coupling list is empty — an RG flow requires ` +
+            `at least one coupling. Define the flow direction in 'couplings'.`);
+    }
+    // ── Predicate 2: every coupling is well-formed; names unique ──────────────
+    const seen = new Set();
+    for (const c of node.couplings) {
+        validateRGCoupling(c);
+        if (seen.has(c.name)) {
+            throw new Error(`BetaFunctionNode: duplicate coupling name '${c.name}' in ` +
+                `couplings list. Each RGCouplingNode must have a unique name.`);
+        }
+        seen.add(c.name);
+    }
+    // ── Predicate 3: target is one of the couplings ───────────────────────────
+    validateRGCoupling(node.target);
+    if (!seen.has(node.target.name)) {
+        throw new Error(`BetaFunctionNode: target coupling '${node.target.name}' is not in ` +
+            `the couplings list [${[...seen].join(', ')}]. The target must be ` +
+            `one of the flow-direction couplings.`);
+    }
+    // ── Predicate 4: polynomialExpansion validates to DIMENSIONLESS ───────────
+    const polyResult = validate(node.polynomialExpansion);
+    if (!polyResult.ok || polyResult.inferredDimension === null) {
+        const noteSummary = polyResult.violations
+            .map((v) => v.note)
+            .join('; ');
+        throw new Error(`BetaFunctionNode: polynomialExpansion failed dimension inference ` +
+            `for target '${node.target.name}' — ${noteSummary || 'no detail available'}.`);
+    }
+    validateComponentDimension('BetaFunctionNode', `polynomialExpansion for target '${node.target.name}'`, polyResult.inferredDimension, DIMENSIONLESS, `must be DIMENSIONLESS (β-function of dimensionless couplings).`);
+    // ── Predicate 5: fixed-point length agrees with couplings count ───────────
+    if (node.fixedPoint !== undefined) {
+        if (node.fixedPoint.length !== node.couplings.length) {
+            throw new Error(`BetaFunctionNode: fixedPoint length mismatch — got ` +
+                `${node.fixedPoint.length} value(s) but couplings list has ` +
+                `${node.couplings.length}. Provide one fixed-point coordinate ` +
+                `per coupling in the same order as 'couplings'.`);
+        }
+        for (let i = 0; i < node.fixedPoint.length; i++) {
+            const v = node.fixedPoint[i];
+            if (!Number.isFinite(v)) {
+                throw new Error(`BetaFunctionNode: fixedPoint[${i}] (coupling ` +
+                    `'${node.couplings[i].name}') is not finite (got ${v}).`);
+            }
+        }
+    }
+    return { dim: DIMENSIONLESS, targetName: node.target.name };
+}
+//# sourceMappingURL=rg-flow.js.map

package/dist/dimensional/rg-flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rg-flow.js","sourceRoot":"","sources":["../../src/dimensional/rg-flow.ts"],"names":[],"mappings":"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"}

package/dist/dimensional/stress-energy-validators.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Stress-energy tensor and cosmological constant AST nodes (v0.6.0 Phase 2).
+ *
+ * Locked to lower-lower variance (Decision #2). Symmetry locked as
+ * explicit field (Decision #12). Antisymmetric T_μν⁺ (Belinfante-Rosenfeld)
+ * deferred to v0.7.0+.
+ *
+ * @module dimensional/stress-energy-validators
+ */
+import type { Dimension } from './types.js';
+import type { CovariantIndex } from './metric-validators.js';
+/**
+ * AST node for the stress-energy tensor T_μν. Rank-2 lower-lower locked
+ * (Decision #2). Symmetric (Decision #12).
+ *
+ * componentDim is the SI dimension of a single component: [M·L⁻¹·T⁻²]
+ * (energy density = Pa = kg·m⁻¹·s⁻²).
+ *
+ * @public
+ */
+export interface StressEnergyTensorNode {
+    readonly kind: 'stress-energy';
+    readonly symbol: 'T';
+    readonly indices: readonly [CovariantIndex, CovariantIndex];
+    readonly symmetry: 'symmetric';
+    readonly componentDim: Dimension;
+}
+/**
+ * AST node for the cosmological constant Λ. Scalar (rank-0), dimension [L⁻²].
+ * Optional numeric value for de Sitter / ΛCDM evaluations.
+ *
+ * @public
+ */
+export interface CosmologicalConstantNode {
+    readonly kind: 'cosmological-constant';
+    readonly symbol: 'Λ';
+    readonly dim: Dimension;
+    readonly value?: number;
+}
+interface StressEnergyValidationResult {
+    readonly dim: Dimension;
+    readonly freeIndices: Map<string, {
+        upper: number;
+        lower: number;
+    }>;
+}
+/**
+ * Validate a `stress-energy` node.
+ *
+ * Throws:
+ *   - Error if rank ≠ 2 (T_μν is a rank-2 tensor by definition).
+ *   - Error if any index variance ≠ 'lower' (lower-lower locked per Decision #2).
+ *
+ * Returns `{dim: componentDim, freeIndices: {idx0: {lower:1}, idx1: {lower:1}}}`.
+ */
+export declare function validateStressEnergyTensor(node: StressEnergyTensorNode): StressEnergyValidationResult;
+interface CosmologicalConstantValidationResult {
+    readonly dim: Dimension;
+    readonly freeIndices: Map<string, {
+        upper: number;
+        lower: number;
+    }>;
+}
+/**
+ * Validate a `cosmological-constant` node.
+ *
+ * Throws:
+ *   - Error if dim ≠ [L⁻²] (check L === -2 && M === 0 && T === 0).
+ *
+ * Returns `{dim, freeIndices: empty}` (scalar — no free indices).
+ */
+export declare function validateCosmologicalConstant(node: CosmologicalConstantNode): CosmologicalConstantValidationResult;
+export {};
+//# sourceMappingURL=stress-energy-validators.d.ts.map

package/dist/dimensional/stress-energy-validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stress-energy-validators.d.ts","sourceRoot":"","sources":["../../src/dimensional/stress-energy-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D;;;;;;;;GAQG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;IAC5D,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC;CAClC;AAED;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAGD,UAAU,4BAA4B;IACpC,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;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,sBAAsB,GAC3B,4BAA4B,CAiB9B;AAGD,UAAU,oCAAoC;IAC5C,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;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,wBAAwB,GAC7B,oCAAoC,CAOtC"}

package/dist/dimensional/stress-energy-validators.js

@@ -0,0 +1,47 @@
+/**
+ * Stress-energy tensor and cosmological constant AST nodes (v0.6.0 Phase 2).
+ *
+ * Locked to lower-lower variance (Decision #2). Symmetry locked as
+ * explicit field (Decision #12). Antisymmetric T_μν⁺ (Belinfante-Rosenfeld)
+ * deferred to v0.7.0+.
+ *
+ * @module dimensional/stress-energy-validators
+ */
+/**
+ * Validate a `stress-energy` node.
+ *
+ * Throws:
+ *   - Error if rank ≠ 2 (T_μν is a rank-2 tensor by definition).
+ *   - Error if any index variance ≠ 'lower' (lower-lower locked per Decision #2).
+ *
+ * Returns `{dim: componentDim, freeIndices: {idx0: {lower:1}, idx1: {lower:1}}}`.
+ */
+export function validateStressEnergyTensor(node) {
+    if (node.indices.length !== 2) {
+        throw new Error(`StressEnergyTensorNode: expected rank-2, got rank-${node.indices.length}`);
+    }
+    for (const idx of node.indices) {
+        if (idx.variance !== 'lower') {
+            throw new Error(`StressEnergyTensorNode: only lower-lower variance supported in v0.6.0 (got '${idx.variance}')`);
+        }
+    }
+    const freeIndices = new Map();
+    freeIndices.set(node.indices[0].label, { upper: 0, lower: 1 });
+    freeIndices.set(node.indices[1].label, { upper: 0, lower: 1 });
+    return { dim: node.componentDim, freeIndices };
+}
+/**
+ * Validate a `cosmological-constant` node.
+ *
+ * Throws:
+ *   - Error if dim ≠ [L⁻²] (check L === -2 && M === 0 && T === 0).
+ *
+ * Returns `{dim, freeIndices: empty}` (scalar — no free indices).
+ */
+export function validateCosmologicalConstant(node) {
+    if (node.dim.L !== -2 || node.dim.M !== 0 || node.dim.T !== 0) {
+        throw new Error(`CosmologicalConstantNode: expected dim [L⁻²], got ${JSON.stringify(node.dim)}`);
+    }
+    return { dim: node.dim, freeIndices: new Map() };
+}
+//# sourceMappingURL=stress-energy-validators.js.map

package/dist/dimensional/stress-energy-validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stress-energy-validators.js","sourceRoot":"","sources":["../../src/dimensional/stress-energy-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAyCH;;;;;;;;GAQG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAA4B;IAE5B,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,qDAAqD,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAC3E,CAAC;IACJ,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;QAC/B,IAAI,GAAG,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CACb,+EAA+E,GAAG,CAAC,QAAQ,IAAI,CAChG,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,GAAG,EAA4C,CAAC;IACxE,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/D,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/D,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,CAAC;AACjD,CAAC;AAQD;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAC1C,IAA8B;IAE9B,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9D,MAAM,IAAI,KAAK,CACb,qDAAqD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAChF,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;AACnD,CAAC"}